If you are not a medium member, you can still read this story here

Part 4: Link
Part 5: Link

Command-line applications (CLI) are lightweight, fast, and extremely useful for automation tasks, system management, and interacting with APIs. Go is a great language for building CLI tools due to its simplicity, strong standard library, and cross-platform compilation.

In this part, Let’s build a simple CLI application in Go that performs a few basic tasks: greeting users, printing the current date, and performing simple calculations. We will start with Go’s standard library and the use some third-party packages.

Prerequisites

• Go installed on your system
• Familiarity with basic Go programming concepts (functions, packages, etc.)

Table of Contents:

1. Introduction to Command Line Applications
2. Setting Up the Project
3. Go’s Standard Flag Package
4. Limitations of the Flag Library
5. The Cobra Library
6. Creating the Root Command
7. Adding Subcommands and Flags
8. Organizing the CLI Application
9. Cross Compilation for Multiple Platforms
10. Packaging and Distributing Go CLI Applications

Setting Up the Project

Create a new directory for your project:

mkdir go-cli-app
cd go-cli-app

Initialize a Go module to manage dependencies:

go mod init go-cli-app

Go’s Standard Flag Package

The Go standard library provides a flag package to parse command-line arguments. Let's start with a simple example that greets the user.

In your main.go add the following code,

package main

import (
    "flag"
    "fmt"
    "os"
)

func main() {
    // Define flags
    name := flag.String("name", "World", "a name to say hello to")
    help := flag.Bool("help", false, "display help")

    // Parse flags
    flag.Parse()

    // Display help if requested
    if *help {
        fmt.Println("Usage: go run main.go [--name your_name] [--help]")
        os.Exit(0)
    }

    // Print greeting
    fmt.Printf("Hello, %s!\n", *name)
}

Flags are a way to pass options to a program via the command line.

Here, two flags are defined:

• --name: Allows the user to specify a name (like --name John). If no name is provided, it defaults to "World".
• --help: A boolean flag that can be used to display usage information. It defaults to false and can be triggered by running the program with --help.

flag.Parse() function processes the flags passed by the user from the command line. After this, the values of the flags are available for use.

If the --help flag is set (meaning the user provided --help in the command line), the program prints usage information (a help message) and then exits. This is not mandatory but its a really good practice to give have some help manual for your application, that prints what the application does, what are the other flags it accepts etc.

Most shell commands like cd, ls etc. have a built in help flag, which can be accessed by passing in -h like ls -h or cd -h .

Finally, we print the name. Now if you run this program using,

go run main.go --name Ben

This will output:

Hello, Ben!

Flag Library Has Limitations

The Go standard flag package is a simple and lightweight library for parsing command-line arguments. However, it comes with several limitations, especially when building more complex command-line interfaces (CLIs).

The flag package does not support subcommands natively. If you need to implement commands like git commit, git push, etc., with subcommands, you have to manually handle this logic.

It also lacks formatting and customization options. For this reason, we often use a more feature-rich third-party library like Cobra that can provide several more options and customization.

The Cobra Library

Cobra is a powerful library for creating modern CLI applications. It solves most of the shortcomings of the flag package and provides a number of additional features. Cobra is widely used in the Go community and has extensive documentation and examples. Popular tools like Kubernetes' CLI (kubectl) are built with Cobra, so the community and support for Cobra are robust.

urfave/cli is also another good option for building CLI applications. However, it is a bit more basic and is not suitable for large applications.

Installing Cobra

First, install cobra using Go's package manager. You'll also need to initialize your Go module if you haven't already.

go get -u github.com/spf13/cobra

Basic Structure of a Cobra Application

A Cobra-based application consists of:

• Root Command: The entry point of the application.
• Subcommands: Specific commands that can be executed (like git init or git commit).
• Flags: Options that modify the behavior of commands (like git commit -m).

Cobra applications typically have a cmd/root.go file and a main.go file. You can create these manually or use cobra-cli, a generator tool that can scaffold the application for you.

Install the cobra-cli tool and initialize your CLI application using cobra-cli:

go install github.com/spf13/cobra-cli@latest
cobra-cli init mycliapp

This will generate the basic structure of your CLI project:

mycliapp/
├── cmd/
│   └── root.go
├── main.go

cmd/root.go: The root command file where the base command logic is defined.

Creating the Root Command

Open cmd/root.go and define the root command:

package cmd

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

var rootCmd = &cobra.Command{
    Use:   "mycli",
    Short: "MyCLI is a simple CLI application",
    Long:  `MyCLI is a demonstration of building CLI applications using Cobra.`,
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Println("Welcome to MyCLI!")
    },
}

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

In main.go, add the following:

package main

import "github.com/yourusername/mycli/cmd"

func main() {
    cmd.Execute()
}

Now if your run the program using go run main.go, you should see the output,

go run main.go

// Output
Welcome to MyCLI!

Adding Subcommands

Next, let’s add a subcommand to the CLI application. We’ll add a greet subcommand.

Create a new file called greet.go in the cmd directory:

package cmd

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

var greetCmd = &cobra.Command{
    Use:   "greet",
    Short: "Print a greeting message",
    Long:  `The greet command prints a greeting message to the console.`,
    Run: func(cmd *cobra.Command, args []string) {
        fmt.Println("Hello, welcome to MyCLI!")
    },
}

func init() {
    rootCmd.AddCommand(greetCmd)
}

In Cobra, commands form a hierarchy. The root command (which in this case is mycli) can have subcommands like greet, and these subcommands can have further subcommands. For example, you could add other subcommands under greet if needed. This structure makes it easy to organize complex CLI applications with nested commands.

The subcommand is added to the root command using the AddCommand function in the init() function.

This means that when the CLI application runs, it will recognize greet as a valid subcommand, and associate it with the root command. The init() function in Go is executed automatically when the package is initialized, making it a convenient place to register subcommands.

You can continue adding multiple subcommands to your application, each with their own specific logic, and Cobra will handle parsing and execution based on what the user types.

Now, run the application with the new greet subcommand:

go run main.go greet

// Output
Hello, welcome to MyCLI!

Adding Flags

Let’s add a name flag to the greet command to make it more dynamic.

package cmd

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

var name string

var greetCmd = &cobra.Command{
    Use:   "greet",
    Short: "Print a greeting message",
    Long:  `The greet command prints a greeting message to the console.`,
    Run: func(cmd *cobra.Command, args []string) {
        if name != "" {
            fmt.Printf("Hello, %s! Welcome to MyCLI!\n", name)
        } else {
            fmt.Println("Hello, welcome to MyCLI!")
        }
    },
}

func init() {
    greetCmd.Flags().StringVarP(&name, "name", "n", "", "Name of the person to greet")
    rootCmd.AddCommand(greetCmd)
}

Now, run the application with the --name flag:

go run main.go greet --name John

// Output
Hello, John! Welcome to MyCLI!

Using Persistent Flags

Persistent flags apply to all commands, not just a specific subcommand. Let’s add a global flag for verbosity.

In cmd/root.go, add a persistent flag:

var verbose bool

func init() {
    rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "Enable verbose output")
}

Modify the Run function in greet.go to check for the verbose flag:

Run: func(cmd *cobra.Command, args []string) {
    if verbose {
        fmt.Println("Verbose output enabled.")
    }

    if name != "" {
        fmt.Printf("Hello, %s! Welcome to MyCLI!\n", name)
    } else {
        fmt.Println("Hello, welcome to MyCLI!")
    }
}

Now, run the command with the verbose flag:

go run main.go greet --name John --verbose

// Output 
Verbose output enabled.
Hello, John! Welcome to MyCLI!

Organizing the CLI Application

As your CLI application grows, organizing the commands into separate files or packages becomes important for maintaining code readability and scalability. Here’s an example of a good directory structure for a larger Cobra-based CLI app:

mycli/
├── cmd/
│   ├── greet.go
│   └── root.go
├── main.go
└── go.mod

Advanced Features

• Auto-Completion: Cobra supports bash, zsh, fish, and PowerShell completion. To add auto-completion for your CLI, you can use:

rootCmd.GenBashCompletion(os.Stdout)

• Help and Usage: Cobra automatically generates help and usage instructions. You can customize these messages by modifying the Short, Long, and Example fields in the &cobra.Command struct.