.
├── cmd
│   ├── cli
│   │   ├── run.go
│   │   └── version.go
│   └── main.go
└── pkg
    ├── example
    │   └── run.go
    └── version
        └── version.go

// This is our main package
package main

// Import required packages
import (
	color "github.com/TwiN/go-color"
	"github.com/mvazquezc/go-cli-template/cmd/cli"
	"github.com/spf13/cobra"
	"log"
	"os"
)

// Our CLI main function
func main() {
    // Create a cobra command that will be the CLI entry-point
	command := newRootCommand()
    // If the command execution fails return the error (this includes errors raised at sub-commands)
	if err := command.Execute(); err != nil {
		log.Fatalf(color.InRed("[ERROR] ")+"%s", err.Error())
	}
}

// newRootCommand implements the root command of example-ci
func newRootCommand() *cobra.Command {
    // Define a new cobra command with the binary name of our CLI and the 
    // This command run without sub-commands will return the help
	c := &cobra.Command{
		Use:   "example-cli",
		Short: "Example cli written in go",
		Run: func(cmd *cobra.Command, args []string) {
            // Return help if no sub-command received
			cmd.Help()
			os.Exit(1)
		},
	}
    // Add sub-commands to our main command
	c.AddCommand(cli.NewRunCommand())
	c.AddCommand(cli.NewVersionCommand())

	return c
}

// This is our cli package
package cli

// Import required packages
import (
	"errors"
	"github.com/mvazquezc/go-cli-template/pkg/example"
	"github.com/spf13/cobra"
)

// Define vars used to store sub-command parameters
var (
	stringParameter      string
	intParameter         int
	stringArrayParameter []string
)

// NewRunCommand implements the run sub-command of example-ci
func NewRunCommand() *cobra.Command {
  // Define a new cobra command for the run sub-command 
  cmd := &cobra.Command{
		Use:   "run",
		Short: "Exec the run command",
		SilenceUsage: true,
		RunE: func(cmd *cobra.Command, args []string) error {
			// Validate command Args with the validateRunCommandArgs function we created
			err := validateRunCommandArgs()
            // If arguments are not valid, return error to the user
			if err != nil {
				return err
			}
			// run command logic is implemented in the example package, we call the function here
			err = example.RunCommandRun(stringParameter)
            // If the command fails, retun error to the user
			if err != nil {
				return err
			}
			return err
		},
	}
    // Add run sub-command flags using the function we created
	addRunCommandFlags(cmd)
	return cmd
}

// addRunCommandFlags receives a cobra command and adds flags to it
func addRunCommandFlags(cmd *cobra.Command) {

    // Define the flags we want to use for our run sub-command
	flags := cmd.Flags()
	flags.StringVarP(&stringParameter, "string-parameter", "s", "", "A string parameter")
	flags.IntVarP(&intParameter, "int-parameter", "i", 1, "An int parameter")
	flags.StringArrayVarP(&stringArrayParameter, "string-array", "a", []string{"example"}, "A string array parameter")
  // We can make flags required
	cmd.MarkFlagRequired("string-parameter")
}

// validateCommandArgs validates that arguments passed by the user are valid
func validateRunCommandArgs() error {
	if intParameter != 1 {
		return errors.New("Not valid int-parameter")
	}
	return nil
}

// This is our example package
package example

import "fmt"

// RunCommandRun has the logic for running the run sub-command
func RunCommandRun(stringParameter string) error {
	fmt.Printf("Run command executed with string parameter set to %s\n.", stringParameter)
	return nil
}

// This is our cli package
package cli

// Import required packages
import (
	"fmt"
	"github.com/mvazquezc/go-cli-template/pkg/version"
	"github.com/spf13/cobra"
)

// Define vars used to store sub-command parameters
var (
	short bool
)

// NewRunCommand implements the version sub-command of example-ci
func NewVersionCommand() *cobra.Command {
    // Define a new cobra command for the version sub-command 
	cmd := &cobra.Command{
		Use:   "version",
		Short: "Display version information",
		RunE: func(cmd *cobra.Command, args []string) error {
			if !short {
				fmt.Printf("Build time: %s\n", version.GetBuildTime())
				fmt.Printf("Git commit: %s\n", version.GetGitCommit())
				fmt.Printf("Go version: %s\n", version.GetGoVersion())
				fmt.Printf("Go compiler: %s\n", version.GetGoCompiler())
				fmt.Printf("Go Platform: %s\n", version.GetGoPlatform())
			} else {
				fmt.Printf("%s\n", version.PrintVersion())
			}
			return nil
		},
	}
    // Add run sub-command flags using the function we created
	addVersionFlags(cmd)
	return cmd
}

// addVersionCommandFlags receives a cobra command and adds flags to it
func addVersionFlags(cmd *cobra.Command) {
	flags := cmd.Flags()
	flags.BoolVar(&short, "short", false, "show only the version number")
}

// This is our version package
package version

import (
	"fmt"
	"runtime"
)

// Define vars used by our package
var (
	version    = "0.0.1"
	buildTime  = "1970-01-01T00:00:00Z"
	gitCommit  = "notSet"
	binaryName = "example-cli"
)

// PrintVersion prints our root command version
func PrintVersion() string {
	version := fmt.Sprintf("%s v%s+%s", binaryName, version, gitCommit)
	return version
}

// GetGitCommit returns the gitCommit
func GetGitCommit() string {
	return gitCommit
}

// GetBuildTime returns the buildTime
func GetBuildTime() string {
	return buildTime
}

// GetGoVersion returns the Version
func GetGoVersion() string {
	return runtime.Version()
}

// GetGoPlatform returns the go platform
func GetGoPlatform() string {
	return runtime.GOOS + "/" + runtime.GOARCH
}
// GetGoCompiler returns the go compiler
func GetGoCompiler() string {
	return runtime.Compiler
}