@@ -31,6 +31,7 @@ func newDaemonCommand() *cobra.Command {

 			opts.flags = cmd.Flags()

 			return runDaemon(opts)

 		},

+		DisableFlagsInUseLine: true,

 	}

 	cli.SetupRootCommand(cmd)

@@ -141,8 +141,8 @@ github.com/pkg/errors 839d9e913e063e28dfd0e6c7b7512793e0a48be9

 github.com/grpc-ecosystem/go-grpc-prometheus 6b7015e65d366bf3f19b2b2a000a831940f0f7e0

 # cli

-github.com/spf13/cobra v1.5.1 https://github.com/dnephin/cobra.git

-github.com/spf13/pflag 9ff6c6923cfffbcd502984b8e0c80539a94968b7

+github.com/spf13/cobra v0.0.3

+github.com/spf13/pflag v1.0.1

 github.com/inconshreveable/mousetrap 76626ae9c91c4f2a10f34cad8ce83ea42c93bb75

 github.com/Nvveen/Gotty a8b993ba6abdb0e0c12b0125c603323a71c7790c https://github.com/ijc25/Gotty

@@ -8,6 +8,7 @@ Many of the most widely used Go projects are built using Cobra including:

 * [Hugo](http://gohugo.io)

 * [rkt](https://github.com/coreos/rkt)

 * [etcd](https://github.com/coreos/etcd)

+* [Moby (former Docker)](https://github.com/moby/moby)

 * [Docker (distribution)](https://github.com/docker/distribution)

 * [OpenShift](https://www.openshift.com/)

 * [Delve](https://github.com/derekparker/delve)

@@ -15,16 +16,37 @@ Many of the most widely used Go projects are built using Cobra including:

 * [CockroachDB](http://www.cockroachlabs.com/)

 * [Bleve](http://www.blevesearch.com/)

 * [ProjectAtomic (enterprise)](http://www.projectatomic.io/)

-* [Parse (CLI)](https://parse.com/)

 * [GiantSwarm's swarm](https://github.com/giantswarm/cli)

 * [Nanobox](https://github.com/nanobox-io/nanobox)/[Nanopack](https://github.com/nanopack)

-

+* [rclone](http://rclone.org/)

+* [nehm](https://github.com/bogem/nehm)

+* [Pouch](https://github.com/alibaba/pouch)

 [![Build Status](https://travis-ci.org/spf13/cobra.svg "Travis CI status")](https://travis-ci.org/spf13/cobra)

 [![CircleCI status](https://circleci.com/gh/spf13/cobra.png?circle-token=:circle-token "CircleCI status")](https://circleci.com/gh/spf13/cobra)

-[![GoDoc](https://godoc.org/github.com/spf13/cobra?status.svg)](https://godoc.org/github.com/spf13/cobra) 

-

-![cobra](https://cloud.githubusercontent.com/assets/173412/10911369/84832a8e-8212-11e5-9f82-cc96660a4794.gif)

+[![GoDoc](https://godoc.org/github.com/spf13/cobra?status.svg)](https://godoc.org/github.com/spf13/cobra)

+

+# Table of Contents

+

+- [Overview](#overview)

+- [Concepts](#concepts)

+  * [Commands](#commands)

+  * [Flags](#flags)

+- [Installing](#installing)

+- [Getting Started](#getting-started)

+  * [Using the Cobra Generator](#using-the-cobra-generator)

+  * [Using the Cobra Library](#using-the-cobra-library)

+  * [Working with Flags](#working-with-flags)

+  * [Positional and Custom Arguments](#positional-and-custom-arguments)

+  * [Example](#example)

+  * [Help Command](#help-command)

+  * [Usage Message](#usage-message)

+  * [PreRun and PostRun Hooks](#prerun-and-postrun-hooks)

+  * [Suggestions when "unknown command" happens](#suggestions-when-unknown-command-happens)

+  * [Generating documentation for your command](#generating-documentation-for-your-command)

+  * [Generating bash completions](#generating-bash-completions)

+- [Contributing](#contributing)

+- [License](#license)

 # Overview

@@ -39,27 +61,16 @@ Cobra provides:

 * Fully POSIX-compliant flags (including short & long versions)

 * Nested subcommands

 * Global, local and cascading flags

-* Easy generation of applications & commands with `cobra create appname` & `cobra add cmdname`

+* Easy generation of applications & commands with `cobra init appname` & `cobra add cmdname`

 * Intelligent suggestions (`app srver`... did you mean `app server`?)

 * Automatic help generation for commands and flags

-* Automatic detailed help for `app help [command]`

 * Automatic help flag recognition of `-h`, `--help`, etc.

 * Automatically generated bash autocomplete for your application

 * Automatically generated man pages for your application

 * Command aliases so you can change things without breaking them

-* The flexibilty to define your own help, usage, etc.

+* The flexibility to define your own help, usage, etc.

 * Optional tight integration with [viper](http://github.com/spf13/viper) for 12-factor apps

-Cobra has an exceptionally clean interface and simple design without needless

-constructors or initialization methods.

-

-Applications built with Cobra commands are designed to be as user-friendly as

-possible. Flags can be placed before or after the command (as long as a

-confusing space isn’t provided). Both short and long flags can be used. A

-command need not even be fully typed.  Help is automatically generated and

-available for the application or for a specific command using either the help

-command or the `--help` flag.

-

 # Concepts

 Cobra is built on a structure of commands, arguments & flags.

@@ -78,11 +89,11 @@ A few good real world examples may better illustrate this point.

 In the following example, 'server' is a command, and 'port' is a flag:

-    > hugo server --port=1313

+    hugo server --port=1313

 In this command we are telling Git to clone the url bare.

-    > git clone URL --bare

+    git clone URL --bare

 ## Commands

@@ -92,20 +103,11 @@ have children commands and optionally run an action.

 In the example above, 'server' is the command.

-A Command has the following structure:

-

-```go

-type Command struct {

-    Use string // The one-line usage message.

-    Short string // The short description shown in the 'help' output.

-    Long string // The long message shown in the 'help <this-command>' output.

-    Run func(cmd *Command, args []string) // Run runs the command.

-}

-```

+[More about cobra.Command](https://godoc.org/github.com/spf13/cobra#Command)

 ## Flags

-A Flag is a way to modify the behavior of a command. Cobra supports

+A flag is a way to modify the behavior of a command. Cobra supports

 fully POSIX-compliant flags as well as the Go [flag package](https://golang.org/pkg/flag/).

 A Cobra command can define flags that persist through to children commands

 and flags that are only available to that command.

@@ -113,23 +115,15 @@ and flags that are only available to that command.

 In the example above, 'port' is the flag.

 Flag functionality is provided by the [pflag

-library](https://github.com/ogier/pflag), a fork of the flag standard library

+library](https://github.com/spf13/pflag), a fork of the flag standard library

 which maintains the same interface while adding POSIX compliance.

-## Usage

-

-Cobra works by creating a set of commands and then organizing them into a tree.

-The tree defines the structure of the application.

-

-Once each command is defined with its corresponding flags, then the

-tree is assigned to the commander which is finally executed.

-

 # Installing

 Using Cobra is easy. First, use `go get` to install the latest version

-of the library. This command will install the `cobra` generator executible

-along with the library:

+of the library. This command will install the `cobra` generator executable

+along with the library and its dependencies:

-    > go get -v github.com/spf13/cobra/cobra

+    go get -u github.com/spf13/cobra/cobra

 Next, include Cobra in your application:

@@ -139,8 +133,8 @@ import "github.com/spf13/cobra"

 # Getting Started

-While you are welcome to provide your own organization, typically a Cobra based

-application will follow the following organizational structure.

+While you are welcome to provide your own organization, typically a Cobra-based

+application will follow the following organizational structure:

 ```

   ▾ appName/

@@ -152,18 +146,20 @@ application will follow the following organizational structure.

       main.go

 ```

-In a Cobra app, typically the main.go file is very bare. It serves, one purpose, to initialize Cobra.

+In a Cobra app, typically the main.go file is very bare. It serves one purpose: initializing Cobra.

 ```go

 package main

-import "{pathToYourApp}/cmd"

+import (

+  "fmt"

+  "os"

+

+  "{pathToYourApp}/cmd"

+)

 func main() {

-	if err := cmd.RootCmd.Execute(); err != nil {

-		fmt.Println(err)

-		os.Exit(-1)

-	}

+  cmd.Execute()

 }

 ```

@@ -172,128 +168,89 @@ func main() {

 Cobra provides its own program that will create your application and add any

 commands you want. It's the easiest way to incorporate Cobra into your application.

-### cobra init

-

-The `cobra init [yourApp]` command will create your initial application code

-for you. It is a very powerful application that will populate your program with

-the right structure so you can immediately enjoy all the benefits of Cobra. It

-will also automatically apply the license you specify to your application.

-

-Cobra init is pretty smart. You can provide it a full path, or simply a path

-similar to what is expected in the import.

-

-```

-cobra init github.com/spf13/newAppName

-```

-

-### cobra add

-

-Once an application is initialized Cobra can create additional commands for you.

-Let's say you created an app and you wanted the following commands for it:

-

-* app serve

-* app config

-* app config create

-

-In your project directory (where your main.go file is) you would run the following:

-

-```

-cobra add serve

-cobra add config

-cobra add create -p 'configCmd'

-```

-

-Once you have run these three commands you would have an app structure that would look like:

-

-```

-  ▾ app/

-    ▾ cmd/

-        serve.go

-        config.go

-        create.go

-      main.go

-```

-

-at this point you can run `go run main.go` and it would run your app. `go run

-main.go serve`, `go run main.go config`, `go run main.go config create` along

-with `go run main.go help serve`, etc would all work.

-

-Obviously you haven't added your own code to these yet, the commands are ready

-for you to give them their tasks. Have fun.

-

-### Configuring the cobra generator

-

-The cobra generator will be easier to use if you provide a simple configuration

-file which will help you eliminate providing a bunch of repeated information in

-flags over and over.

-

-An example ~/.cobra.yaml file:

-

-```yaml

-author: Steve Francia <spf@spf13.com>

-license: MIT

-```

-

-You can specify no license by setting `license` to `none` or you can specify

-a custom license:

+[Here](https://github.com/spf13/cobra/blob/master/cobra/README.md) you can find more information about it.

-```yaml

-license:

-  header: This file is part of {{ .appName }}.

-  text: |

-    {{ .copyright }}

+## Using the Cobra Library

-    This is my license. There are many like it, but this one is mine.

-    My license is my best friend. It is my life. I must master it as I must

-    master my life.  

-```

-

-## Manually implementing Cobra

-

-To manually implement cobra you need to create a bare main.go file and a RootCmd file.

+To manually implement Cobra you need to create a bare main.go file and a rootCmd file.

 You will optionally provide additional commands as you see fit.

-### Create the root command

-

-The root command represents your binary itself.

-

-

-#### Manually create rootCmd

+### Create rootCmd

 Cobra doesn't require any special constructors. Simply create your commands.

 Ideally you place this in app/cmd/root.go:

 ```go

-var RootCmd = &cobra.Command{

-	Use:   "hugo",

-	Short: "Hugo is a very fast static site generator",

-	Long: `A Fast and Flexible Static Site Generator built with

+var rootCmd = &cobra.Command{

+  Use:   "hugo",

+  Short: "Hugo is a very fast static site generator",

+  Long: `A Fast and Flexible Static Site Generator built with

                 love by spf13 and friends in Go.

                 Complete documentation is available at http://hugo.spf13.com`,

-	Run: func(cmd *cobra.Command, args []string) {

-		// Do Stuff Here

-	},

+  Run: func(cmd *cobra.Command, args []string) {

+    // Do Stuff Here

+  },

+}

+

+func Execute() {

+  if err := rootCmd.Execute(); err != nil {

+    fmt.Println(err)

+    os.Exit(1)

+  }

 }

 ```

 You will additionally define flags and handle configuration in your init() function.

-for example cmd/root.go:

+For example cmd/root.go:

 ```go

+import (

+  "fmt"

+  "os"

+

+  homedir "github.com/mitchellh/go-homedir"

+  "github.com/spf13/cobra"

+  "github.com/spf13/viper"

+)

+

 func init() {

-	cobra.OnInitialize(initConfig)

-	RootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.cobra.yaml)")

-	RootCmd.PersistentFlags().StringVarP(&projectBase, "projectbase", "b", "", "base project directory eg. github.com/spf13/")

-	RootCmd.PersistentFlags().StringP("author", "a", "YOUR NAME", "Author name for copyright attribution")

-	RootCmd.PersistentFlags().StringVarP(&userLicense, "license", "l", "", "Name of license for the project (can provide `licensetext` in config)")

-	RootCmd.PersistentFlags().Bool("viper", true, "Use Viper for configuration")

-	viper.BindPFlag("author", RootCmd.PersistentFlags().Lookup("author"))

-	viper.BindPFlag("projectbase", RootCmd.PersistentFlags().Lookup("projectbase"))

-	viper.BindPFlag("useViper", RootCmd.PersistentFlags().Lookup("viper"))

-	viper.SetDefault("author", "NAME HERE <EMAIL ADDRESS>")

-	viper.SetDefault("license", "apache")

+  cobra.OnInitialize(initConfig)

+  rootCmd.PersistentFlags().StringVar(&cfgFile, "config", "", "config file (default is $HOME/.cobra.yaml)")

+  rootCmd.PersistentFlags().StringVarP(&projectBase, "projectbase", "b", "", "base project directory eg. github.com/spf13/")

+  rootCmd.PersistentFlags().StringP("author", "a", "YOUR NAME", "Author name for copyright attribution")

+  rootCmd.PersistentFlags().StringVarP(&userLicense, "license", "l", "", "Name of license for the project (can provide `licensetext` in config)")

+  rootCmd.PersistentFlags().Bool("viper", true, "Use Viper for configuration")

+  viper.BindPFlag("author", rootCmd.PersistentFlags().Lookup("author"))

+  viper.BindPFlag("projectbase", rootCmd.PersistentFlags().Lookup("projectbase"))

+  viper.BindPFlag("useViper", rootCmd.PersistentFlags().Lookup("viper"))

+  viper.SetDefault("author", "NAME HERE <EMAIL ADDRESS>")

+  viper.SetDefault("license", "apache")

+}

+

+func initConfig() {

+  // Don't forget to read config either from cfgFile or from home directory!

+  if cfgFile != "" {

+    // Use config file from the flag.

+    viper.SetConfigFile(cfgFile)

+  } else {

+    // Find home directory.

+    home, err := homedir.Dir()

+    if err != nil {

+      fmt.Println(err)

+      os.Exit(1)

+    }

+

+    // Search config in home directory with name ".cobra" (without extension).

+    viper.AddConfigPath(home)

+    viper.SetConfigName(".cobra")

+  }

+

+  if err := viper.ReadInConfig(); err != nil {

+    fmt.Println("Can't read config:", err)

+    os.Exit(1)

+  }

 }

 ```

@@ -307,17 +264,18 @@ In a Cobra app, typically the main.go file is very bare. It serves, one purpose,

 ```go

 package main

-import "{pathToYourApp}/cmd"

+import (

+  "fmt"

+  "os"

+

+  "{pathToYourApp}/cmd"

+)

 func main() {

-	if err := cmd.RootCmd.Execute(); err != nil {

-		fmt.Println(err)

-		os.Exit(-1)

-	}

+  cmd.Execute()

 }

 ```

-

 ### Create additional commands

 Additional commands can be defined and typically are each given their own file

@@ -330,47 +288,25 @@ populate it with the following:

 package cmd

 import (

-	"github.com/spf13/cobra"

+  "fmt"

+

+  "github.com/spf13/cobra"

 )

 func init() {

-	RootCmd.AddCommand(versionCmd)

+  rootCmd.AddCommand(versionCmd)

 }

 var versionCmd = &cobra.Command{

-	Use:   "version",

-	Short: "Print the version number of Hugo",

-	Long:  `All software has versions. This is Hugo's`,

-	Run: func(cmd *cobra.Command, args []string) {

-		fmt.Println("Hugo Static Site Generator v0.9 -- HEAD")

-	},

+  Use:   "version",

+  Short: "Print the version number of Hugo",

+  Long:  `All software has versions. This is Hugo's`,

+  Run: func(cmd *cobra.Command, args []string) {

+    fmt.Println("Hugo Static Site Generator v0.9 -- HEAD")

+  },

 }

 ```

-### Attach command to its parent

-

-

-If you notice in the above example we attach the command to its parent. In

-this case the parent is the rootCmd. In this example we are attaching it to the

-root, but commands can be attached at any level.

-

-```go

-RootCmd.AddCommand(versionCmd)

-```

-

-### Remove a command from its parent

-

-Removing a command is not a common action in simple programs, but it allows 3rd

-parties to customize an existing command tree.

-

-In this example, we remove the existing `VersionCmd` command of an existing

-root command, and we replace it with our own version:

-

-```go

-mainlib.RootCmd.RemoveCommand(mainlib.VersionCmd)

-mainlib.RootCmd.AddCommand(versionCmd)

-```

-

 ## Working with Flags

 Flags provide modifiers to control how the action command operates.

@@ -395,7 +331,7 @@ command it's assigned to as well as every command under that command. For

 global flags, assign a flag as a persistent flag on the root.

 ```go

-RootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")

+rootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose output")

 ```

 ### Local Flags

@@ -403,43 +339,81 @@ RootCmd.PersistentFlags().BoolVarP(&Verbose, "verbose", "v", false, "verbose out

 A flag can also be assigned locally which will only apply to that specific command.

 ```go

-RootCmd.Flags().StringVarP(&Source, "source", "s", "", "Source directory to read from")

+rootCmd.Flags().StringVarP(&Source, "source", "s", "", "Source directory to read from")

+```

+

+### Local Flag on Parent Commands

+

+By default Cobra only parses local flags on the target command, any local flags on

+parent commands are ignored. By enabling `Command.TraverseChildren` Cobra will

+parse local flags on each command before executing the target command.

+

+```go

+command := cobra.Command{

+  Use: "print [OPTIONS] [COMMANDS]",

+  TraverseChildren: true,

+}

+```

+

+### Bind Flags with Config

+

+You can also bind your flags with [viper](https://github.com/spf13/viper):

+```go

+var author string

+

+func init() {

+  rootCmd.PersistentFlags().StringVar(&author, "author", "YOUR NAME", "Author name for copyright attribution")

+  viper.BindPFlag("author", rootCmd.PersistentFlags().Lookup("author"))

+}

 ```

-### Positional Arguments

+In this example the persistent flag `author` is bound with `viper`.

+**Note**, that the variable `author` will not be set to the value from config,

+when the `--author` flag is not provided by user.

+

+More in [viper documentation](https://github.com/spf13/viper#working-with-flags).

+

+### Required flags

+

+Flags are optional by default. If instead you wish your command to report an error

+when a flag has not been set, mark it as required:

+```go

+rootCmd.Flags().StringVarP(&Region, "region", "r", "", "AWS region (required)")

+rootCmd.MarkFlagRequired("region")

+```

+

+## Positional and Custom Arguments

+

+Validation of positional arguments can be specified using the `Args` field

+of `Command`.

-Validation of positional arguments can be specified using the `Args` field, which accepts

-one of the following values:

+The following validators are built in:

 - `NoArgs` - the command will report an error if there are any positional args.

 - `ArbitraryArgs` - the command will accept any args.

-- `OnlyValidArgs` - the command will report an error if there are any positiona 

-  args that are not in the `ValidArgs` list.

-- `MinimumNArgs(int)` - the command will report an error if there are not at 

-  least N positional args.

-- `MaximumNArgs(int)` - the command will report an error if there are more than 

-  N positional args.

-- `ExactArgs(int)` - the command will report an error if there are not 

-  exactly N positional args.

-- `RangeArgs(min, max)` - the command will report an error if the number of args 

-  is not between the minimum and maximum number of expected args.

-

-By default, `Args` uses the following legacy behaviour:

-- root commands with no subcommands can take arbitrary arguments

-- root commands with subcommands will do subcommand validity checking

-- subcommands will always accept arbitrary arguments and do no subsubcommand validity checking

+- `OnlyValidArgs` - the command will report an error if there are any positional args that are not in the `ValidArgs` field of `Command`.

+- `MinimumNArgs(int)` - the command will report an error if there are not at least N positional args.

+- `MaximumNArgs(int)` - the command will report an error if there are more than N positional args.

+- `ExactArgs(int)` - the command will report an error if there are not exactly N positional args.

+- `RangeArgs(min, max)` - the command will report an error if the number of args is not between the minimum and maximum number of expected args.

+An example of setting the custom validator:

 ```go

-var HugoCmd = &cobra.Command{

-    Use:   "hugo",

-    Short: "Hugo is a very fast static site generator",

-    ValidArgs: []string{"one", "two"}

-    Args: cobra.OnlyValidArgs

-    Run: func(cmd *cobra.Command, args []string) {

-        // args will only have the values one, two

-        // or the cmd.Execute() will fail.

-    },

+var cmd = &cobra.Command{

+  Short: "hello",

+  Args: func(cmd *cobra.Command, args []string) error {

+    if len(args) < 1 {

+      return errors.New("requires at least one arg")

+    }

+    if myapp.IsValidColor(args[0]) {

+      return nil

+    }

+    return fmt.Errorf("invalid color specified: %s", args[0])

+  },

+  Run: func(cmd *cobra.Command, args []string) {

+    fmt.Println("Hello, World!")

+  },

 }

 ```

@@ -458,62 +432,62 @@ More documentation about flags is available at https://github.com/spf13/pflag

 package main

 import (

-	"fmt"

-	"strings"

+  "fmt"

+  "strings"

-	"github.com/spf13/cobra"

+  "github.com/spf13/cobra"

 )

 func main() {

+  var echoTimes int

+

+  var cmdPrint = &cobra.Command{

+    Use:   "print [string to print]",

+    Short: "Print anything to the screen",

+    Long: `print is for printing anything back to the screen.

+For many years people have printed back to the screen.`,

+    Args: cobra.MinimumNArgs(1),

+    Run: func(cmd *cobra.Command, args []string) {

+      fmt.Println("Print: " + strings.Join(args, " "))

+    },

+  }

+

+  var cmdEcho = &cobra.Command{

+    Use:   "echo [string to echo]",

+    Short: "Echo anything to the screen",

+    Long: `echo is for echoing anything back.

+Echo works a lot like print, except it has a child command.`,

+    Args: cobra.MinimumNArgs(1),

+    Run: func(cmd *cobra.Command, args []string) {

+      fmt.Println("Print: " + strings.Join(args, " "))

+    },

+  }

+

+  var cmdTimes = &cobra.Command{

+    Use:   "times [# times] [string to echo]",

+    Short: "Echo anything to the screen more times",

+    Long: `echo things multiple times back to the user by providing

+a count and a string.`,

+    Args: cobra.MinimumNArgs(1),

+    Run: func(cmd *cobra.Command, args []string) {

+      for i := 0; i < echoTimes; i++ {

+        fmt.Println("Echo: " + strings.Join(args, " "))

+      }

+    },

+  }

-	var echoTimes int

-

-	var cmdPrint = &cobra.Command{

-		Use:   "print [string to print]",

-		Short: "Print anything to the screen",

-		Long: `print is for printing anything back to the screen.

-            For many years people have printed back to the screen.

-            `,

-		Run: func(cmd *cobra.Command, args []string) {

-			fmt.Println("Print: " + strings.Join(args, " "))

-		},

-	}

-

-	var cmdEcho = &cobra.Command{

-		Use:   "echo [string to echo]",

-		Short: "Echo anything to the screen",

-		Long: `echo is for echoing anything back.

-            Echo works a lot like print, except it has a child command.

-            `,

-		Run: func(cmd *cobra.Command, args []string) {

-			fmt.Println("Print: " + strings.Join(args, " "))

-		},

-	}

-

-	var cmdTimes = &cobra.Command{

-		Use:   "times [# times] [string to echo]",

-		Short: "Echo anything to the screen more times",

-		Long: `echo things multiple times back to the user by providing

-            a count and a string.`,

-		Run: func(cmd *cobra.Command, args []string) {

-			for i := 0; i < echoTimes; i++ {

-				fmt.Println("Echo: " + strings.Join(args, " "))

-			}

-		},

-	}

-

-	cmdTimes.Flags().IntVarP(&echoTimes, "times", "t", 1, "times to echo the input")

-

-	var rootCmd = &cobra.Command{Use: "app"}

-	rootCmd.AddCommand(cmdPrint, cmdEcho)

-	cmdEcho.AddCommand(cmdTimes)

-	rootCmd.Execute()

+  cmdTimes.Flags().IntVarP(&echoTimes, "times", "t", 1, "times to echo the input")

+

+  var rootCmd = &cobra.Command{Use: "app"}

+  rootCmd.AddCommand(cmdPrint, cmdEcho)

+  cmdEcho.AddCommand(cmdTimes)

+  rootCmd.Execute()

 }

 ```

 For a more complete example of a larger application, please checkout [Hugo](http://gohugo.io/).

-## The Help Command

+## Help Command

 Cobra automatically adds a help command to your application when you have subcommands.

 This will be called when a user runs 'app help'. Additionally, help will also

@@ -526,60 +500,28 @@ create' is called.  Every command will automatically have the '--help' flag adde

 The following output is automatically generated by Cobra. Nothing beyond the

 command and flag definitions are needed.

-    > hugo help

-

-    hugo is the main command, used to build your Hugo site.

+    $ cobra help

-    Hugo is a Fast and Flexible Static Site Generator

-    built with love by spf13 and friends in Go.

-

-    Complete documentation is available at http://gohugo.io/.

+    Cobra is a CLI library for Go that empowers applications.

+    This application is a tool to generate the needed files

+    to quickly create a Cobra application.

     Usage:

-      hugo [flags]

-      hugo [command]

+      cobra [command]

     Available Commands:

-      server          Hugo runs its own webserver to render the files

-      version         Print the version number of Hugo

-      config          Print the site configuration

-      check           Check content in the source directory

-      benchmark       Benchmark hugo by building a site a number of times.

-      convert         Convert your content to different formats

-      new             Create new content for your site

-      list            Listing out various types of content

-      undraft         Undraft changes the content's draft status from 'True' to 'False'

-      genautocomplete Generate shell autocompletion script for Hugo

-      gendoc          Generate Markdown documentation for the Hugo CLI.

-      genman          Generate man page for Hugo

-      import          Import your site from others.

+      add         Add a command to a Cobra Application

+      help        Help about any command

+      init        Initialize a Cobra Application

     Flags:

-      -b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/

-      -D, --buildDrafts[=false]: include content marked as draft

-      -F, --buildFuture[=false]: include content with publishdate in the future

-          --cacheDir="": filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/

-          --canonifyURLs[=false]: if true, all relative URLs will be canonicalized using baseURL

-          --config="": config file (default is path/config.yaml|json|toml)

-      -d, --destination="": filesystem path to write files to

-          --disableRSS[=false]: Do not build RSS files

-          --disableSitemap[=false]: Do not build Sitemap file

-          --editor="": edit new content with this editor, if provided

-          --ignoreCache[=false]: Ignores the cache directory for reading but still writes to it

-          --log[=false]: Enable Logging

-          --logFile="": Log File path (if set, logging enabled automatically)

-          --noTimes[=false]: Don't sync modification time of files

-          --pluralizeListTitles[=true]: Pluralize titles in lists using inflect

-          --preserveTaxonomyNames[=false]: Preserve taxonomy names as written ("Gérard Depardieu" vs "gerard-depardieu")

-      -s, --source="": filesystem path to read files relative from

-          --stepAnalysis[=false]: display memory and timing of different steps of the program

-      -t, --theme="": theme to use (located in /themes/THEMENAME/)

-          --uglyURLs[=false]: if true, use /filename.html instead of /filename/

-      -v, --verbose[=false]: verbose output

-          --verboseLog[=false]: verbose logging

-      -w, --watch[=false]: watch filesystem for changes and recreate as needed

-

-    Use "hugo [command] --help" for more information about a command.

+      -a, --author string    author name for copyright attribution (default "YOUR NAME")

+          --config string    config file (default is $HOME/.cobra.yaml)

+      -h, --help             help for cobra

+      -l, --license string   name of license for the project

+          --viper            use Viper for configuration (default true)

+

+    Use "cobra [command] --help" for more information about a command.

 Help is just a command like any other. There is no special logic or behavior

@@ -587,38 +529,18 @@ around it. In fact, you can provide your own if you want.

 ### Defining your own help

-You can provide your own Help command or your own template for the default command to use.

-

-The default help command is

-

-```go

-func (c *Command) initHelp() {

-	if c.helpCommand == nil {

-		c.helpCommand = &Command{

-			Use:   "help [command]",

-			Short: "Help about any command",

-			Long: `Help provides help for any command in the application.

-        Simply type ` + c.Name() + ` help [path to command] for full details.`,

-			Run: c.HelpFunc(),

-		}

-	}

-	c.AddCommand(c.helpCommand)

-}

-```

-

-You can provide your own command, function or template through the following methods:

+You can provide your own Help command or your own template for the default command to use

+with following functions:

 ```go

-command.SetHelpCommand(cmd *Command)

-

-command.SetHelpFunc(f func(*Command, []string))

-

-command.SetHelpTemplate(s string)

+cmd.SetHelpCommand(cmd *Command)

+cmd.SetHelpFunc(f func(*Command, []string))

+cmd.SetHelpTemplate(s string)

 ```

 The latter two will also apply to any children commands.

-## Usage

+## Usage Message

 When the user provides an invalid flag or invalid command, Cobra responds by

 showing the user the 'usage'.

@@ -627,73 +549,44 @@ showing the user the 'usage'.

 You may recognize this from the help above. That's because the default help

 embeds the usage as part of its output.

+    $ cobra --invalid

+    Error: unknown flag: --invalid

     Usage:

-      hugo [flags]

-      hugo [command]

+      cobra [command]

     Available Commands:

-      server          Hugo runs its own webserver to render the files

-      version         Print the version number of Hugo

-      config          Print the site configuration

-      check           Check content in the source directory

-      benchmark       Benchmark hugo by building a site a number of times.

-      convert         Convert your content to different formats

-      new             Create new content for your site

-      list            Listing out various types of content

-      undraft         Undraft changes the content's draft status from 'True' to 'False'

-      genautocomplete Generate shell autocompletion script for Hugo

-      gendoc          Generate Markdown documentation for the Hugo CLI.

-      genman          Generate man page for Hugo

-      import          Import your site from others.

+      add         Add a command to a Cobra Application

+      help        Help about any command

+      init        Initialize a Cobra Application

     Flags:

-      -b, --baseURL="": hostname (and path) to the root, e.g. http://spf13.com/

-      -D, --buildDrafts[=false]: include content marked as draft

-      -F, --buildFuture[=false]: include content with publishdate in the future

-          --cacheDir="": filesystem path to cache directory. Defaults: $TMPDIR/hugo_cache/

-          --canonifyURLs[=false]: if true, all relative URLs will be canonicalized using baseURL

-          --config="": config file (default is path/config.yaml|json|toml)

-      -d, --destination="": filesystem path to write files to

-          --disableRSS[=false]: Do not build RSS files

-          --disableSitemap[=false]: Do not build Sitemap file

-          --editor="": edit new content with this editor, if provided

-          --ignoreCache[=false]: Ignores the cache directory for reading but still writes to it

-          --log[=false]: Enable Logging

-          --logFile="": Log File path (if set, logging enabled automatically)

-          --noTimes[=false]: Don't sync modification time of files

-          --pluralizeListTitles[=true]: Pluralize titles in lists using inflect