chzyer/readline

The readline library is a multi-platform Go library designed for powerful line editing in terminal applications. It provides the following core capabilities:

• Multi-platform support: Works across different operating systems.
• Line editing: Supports common keyboard shortcut keys for navigating and editing text.
• History support: Allows users to navigate through previous commands with customizable persistence (saving/loading history).
• Completion support: Enables tab-completion for commands or inputs.
• Custom prompts: Supports customizable prompt strings to guide user input.

The remote communication uses a custom message format defined by the Message struct. Every message is prefixed with a length and a type.

Message Structure (BigEndian):

1. length (int32): The total size of the message payload including the type field (length = 2 + len(Data)).
2. type (int16): The MsgType identifier.
3. data ([]byte): The raw payload.

Supported MsgType values:

• T_DATA (0): Contains raw data to be read or written.
• T_WIDTH (1): Used for width reporting.
• T_WIDTH_REPORT (2): Client reporting its terminal width to the server.
• T_ISTTY_REPORT (3): Client reporting if it is a terminal to the server.
• T_RAW (4): Command to enter raw mode.
• T_ERAW (5): Command to exit raw mode.
• T_EOF (6): Signal that the connection is closing/EOF reached.

If you need to provide completions that change based on the current state or input (like file paths or dynamic IDs), use PcItemDynamic. This requires a DynamicCompleteFunc, which is a function that takes a string and returns a slice of []string representing the available completions.

When a PrefixCompleter is marked as Dynamic, the completion engine calls its Callback to retrieve the available names for the current line.

The opHistory type manages the lifecycle of command history, including in-memory storage, persistence to a file, and searching. It is typically initialized via newOpHistory(cfg *Config) and used to track user inputs.

Key capabilities include:

• Persistence: Automatically saves history to the path specified in Config.HistoryFile.
• Navigation: Move through history using Prev() and Next().
• Searching: Search backwards (FindBck) or forwards (FindFwd) through history items.
• Lifecycle Management: Use New(current []rune) to commit a new command to history, Update(s []rune, commit bool) to modify the current item, and Revert() to return to the last known state.

To use readline for a simple interactive command-line interface, use readline.New(prompt) to create an instance, then loop over rl.Readline() to capture user input. Always ensure you defer rl.Close() to clean up resources.

rl, err := readline.New("> ")
if err != nil {
	panic(err)
}
defer rl.Close()

for {
	line, err := rl.Readline()
	if err != nil { // io.EOF
		break
	}
	println(line)
}

The readline package provides a tree-based completion system using PrefixCompleter. You can build a hierarchy of commands and subcommands by nesting PrefixCompleter instances.

To build a static tree, use PcItem(name, children...). To build a dynamic tree where names are generated at runtime (e.g., based on current input), use PcItemDynamic(callback, children...).

To perform the actual completion logic against a line of text, call Do(completer, line, pos).

You can restrict what characters the user is allowed to type by providing a function to Config.FuncFilterInputRune. This function is called for every rune read from the terminal.

FuncFilterInputRune signature: func(r rune) (rune, bool)

• If it returns false for the second value, the rune is ignored and the buffer is refreshed.
• If it returns true, the (potentially modified) rune is processed.

Enter Search Mode by pressing Ctrl+S or Ctrl+R. While in Search Mode, use the following shortcuts:

Enter Complete Select Mode by pressing Tab twice. While in this mode, use the following shortcuts to navigate and select candidates: