Add Terminal Completion to Your Command Line Apps

Understanding Auto-Completion in Shells

Auto-completion is a powerful feature that enhances user interaction with command-line tools. It allows users to type partial commands and receive suggestions, making the process more efficient and less error-prone. This functionality has been part of Unix systems since the 1980s, and modern shells like Bash and Zsh have developed robust completion ecosystems.

How Tab Completion Works

Tab completion is commonly used for commands and filenames. When you press the Tab key, the shell inspects the PATH environment variable to find available commands that match the letters you've typed. For filenames, it helps complete file paths and resolve ambiguities as you type. These features save time and reduce manual input.

However, there's another form of completion—argument autocompletion—that is often overlooked but can be even more powerful. This type of completion applies to options or subcommands following a command name.

Adding Custom Completion to Your Scripts

To add custom completion for your scripts, you can start by creating a simple script. For example, consider a script named "todos" that manages a to-do list. The script can handle subcommands like "edit" and "help." While this script may not be complex, it serves as a good demonstration for adding auto-completion.

Creating a Custom Completion Script

In Zsh, the most basic completion is straightforward. You define a function that specifies possible completions using the compadd command. Then, you load the compinit module and connect the function to the command using compdef. This setup allows for immediate tab completion suggestions.

For Bash, the approach is slightly different. Instead of functions, you use the complete command and set the COMPREPLY variable. This variable holds an array of possible completions. However, Bash does not automatically apply logic to filter suggestions, so you must handle this manually.

Handling Contextual Suggestions in Bash

Bash provides variables like COMP_WORDS and COMP_CWORD that help determine which word is being completed. Using these variables, you can generate context-specific suggestions. The compgen command is useful for generating suggestions based on static lists or other criteria.

Making Your Script Portable

To make your completion script work across different shells, you can detect the current shell and run the appropriate code. For example, you can check if ZSH_VERSION or BASH_VERSION is set and execute the corresponding completion logic. This ensures compatibility and flexibility.

Putting Everything Together

A complete script that works in both Zsh and Bash can store its suggestions in a variable accessible to both functions. Zsh uses compadd, while Bash sets the COMPREPLY variable. This approach allows for a unified completion system that adapts to the user's environment.

Source Your Completion Script

Once you have created your completion script, you can source it from your .bashrc or .zshrc files. This ensures that the completion functionality is available every time you start a new shell session.

Exploring Further Possibilities

While this guide covers the basics of adding auto-completion to scripts, there are many advanced techniques to explore. A robust completion script should consider the full command line and account for various arguments that might affect the current completion. By building on these foundations, you can create more sophisticated and user-friendly command-line tools.