Cobra Golang's CLI Library

Introduction

In Go (Golang), "cobra" is a popular and widely used command-line interface (CLI) library. Cobra provides a simple and elegant way to create powerful and extensible command-line applications in Go. It was created by spf13 and is widely adopted in the Go community for building command-line tools due to its flexibility and ease of use.

Here are some key features and concepts associated with Cobra

• Commands and Flags: Commands: Cobra allows you to define commands, which are essentially the actions or operations your CLI tool can perform. Each command can have its own set of flags and arguments. Flags: Flags are used to pass options or parameters to commands. They can be global (available to all commands) or specific to a particular command.
• Hierarchical Structure: Cobra supports a hierarchical structure for commands, allowing you to organize your CLI tool in a way that makes sense for your application. This makes it easy to add new features or functionalities without cluttering the command-line interface.
• Automatic Help Generation: Cobra can automatically generate help information for your CLI tool, making it easier for users to understand how to use your commands and what options are available.
• Hooks and Middleware: Cobra provides hooks and middleware, allowing you to add functionality before, after, or around command execution. This can be useful for tasks like authentication, logging, or any other pre- or post-processing.
• Command Aliases: You can define aliases for commands, making it more user-friendly and allowing different ways to invoke the same functionality.

Now, let's look at a simple example to illustrate the basic usage of Cobra in a Go application:

package main

import (
    "fmt"
    "github.com/spf13/cobra"
    "os"
)

func main() {
    var rootCmd = &cobra.Command{Use: "myapp"}

    var helloCmd = &cobra.Command{
        Use:   "hello",
        Short: "Prints 'Hello, World!'",
        Run: func(cmd *cobra.Command, args []string) {
            fmt.Println("Hello, World!")
        },
    }

    var greetCmd = &cobra.Command{
        Use:   "greet",
        Short: "Greet a person",
        Run: func(cmd *cobra.Command, args []string) {
            if len(args) > 0 {
                fmt.Printf("Hello, %s!\n", args[0])
            } else {
                fmt.Println("Please provide a name.")
            }
        },
    }

    rootCmd.AddCommand(helloCmd, greetCmd)

    if err := rootCmd.Execute(); err != nil {
        fmt.Println(err)
        os.Exit(1)
    }
}

In this example:

• rootCmd is the main command for your CLI tool.
• helloCmd is a subcommand that prints "Hello, World!" when executed.
• greetCmd is another subcommand that takes a person's name as an argument and prints a personalized greeting.
• You can buil d this program and try running commands like:

./myapp hello
./myapp greet John

This is just a basic example, and Cobra provides many more features for building complex and feature-rich command-line applications in Go.

Common Go Apps Utilize the power of Cobra

Numerous popular open-source projects have adopted Cobra for their CLI interfaces, leveraging its flexibility and ease of use. Here are some notable examples:

• Kubernetes (kubectl): Kubernetes, the widely adopted container orchestration platform, utilizes Cobra for its kubectl command-line tool. Cobra enables the management of Kubernetes clusters, including creating, deleting, and modifying deployments, pods, and services.
• Hugo: Hugo, a popular static site generator written in Go, employs Cobra for its CLI interface. Cobra facilitates the creation, building, and management of Hugo-based websites, offering commands for generating pages, converting content formats, and deploying sites.
• Docker (CLI): Docker, a platform for automating the deployment, scaling, and management of applications, utilizes Cobra for its command-line interface. Cobra empowers users to build, run, manage, and distribute Docker containers seamlessly.

To summarize

Cobra is a popular Go library for creating powerful modern CLI applications. It provides a framework for defining commands and their flags, as well as handling command-line parsing, configuration management, and user interaction. Numerous popular open-source projects have adopted Cobra for their CLI interfaces, leveraging its flexibility and ease of use.

Comments

[Wynand Pieters]

Really love the Cobra framework, been using it to build CLIs for years. One of the greatest features they've added in the last while is support for a completion command.

By running ./myapp completion --help you can see a list of available command, i.e.

Available Commands:
  bash        Generate the autocompletion script for bash
  fish        Generate the autocompletion script for fish
  powershell  Generate the autocompletion script for powershell
  zsh         Generate the autocompletion script for zsh

And then running help for a specific one tells you how to load it into your shell of choice, e.g. ./myapp completion fish --help will give

Generate the autocompletion script for the fish shell.

To load completions in your current shell session:

    myapp completion fish | source

To load completions for every new session, execute once:

    myapp completion fish > ~/.config/fish/completions/myapp.fish

You will need to start a new shell for this setup to take effect.

Et voila. Tab completion for your custom CLI. Awesome feature to just get out the box given how powerful the framework already is.