func DefaultAppComplete(ctxcontext.Context, cmd *Command)

func DefaultCompleteWithFlags(ctxcontext.Context, cmd *Command)

func FlagNames(namestring, aliases []string) []string

func HandleExitCoder(errerror)

func ShowAppHelp(cmd *Command)error

func ShowAppHelpAndExit(cmd *Command, exitCodeint)

func ShowCommandHelp(ctxcontext.Context, cmd *Command, commandNamestring)error

func ShowCommandHelpAndExit(ctxcontext.Context, cmd *Command, commandstring, codeint)

func ShowSubcommandHelp(cmd *Command)error

func ShowSubcommandHelpAndExit(cmd *Command, exitCodeint)

func ShowVersion(cmd *Command)

type ActionFunc func(context.Context, *Command)error

type ActionableFlag interface {RunAction(context.Context, *Command)error}

type AfterFunc func(context.Context, *Command)error

type Args interface {// Get returns the nth argument, or else a blank stringGet(nint)string// First returns the first argument, or else a blank stringFirst()string// Tail returns the rest of the arguments (not the first one)// or else an empty string sliceTail() []string// Len returns the length of the wrapped sliceLen()int// Present checks if there are any arguments presentPresent()bool// Slice returns a copy of the internal sliceSlice() []string}

type Argument interface {Parse([]string) ([]string,error)Usage()string}

type ArgumentBase[Tany, Cany, VCValueCreator[T, C]] struct {Namestring `json:"name"`// the name of this argumentValue       T      `json:"value"`// the default value of this argumentDestination *T     `json:"-"`// the destination point for this argumentValues      *[]T   `json:"-"`// all the values of this argument, only if multiple are supportedUsageTextstring `json:"usageText"`// the usage text to showMinint    `json:"minTimes"`// the min num of occurrences of this argumentMaxint    `json:"maxTimes"`// the max num of occurrences of this argument, set to -1 for unlimitedConfig      C      `json:"config"`// config for this argument similar to Flag Config}

func (*ArgumentBase[T, C, VC])Parse¶

func (a *ArgumentBase[T, C, VC]) Parse(s []string) ([]string,error)

func (*ArgumentBase[T, C, VC])Usage¶

func (a *ArgumentBase[T, C, VC]) Usage()string

type BeforeFunc func(context.Context, *Command) (context.Context,error)

type BoolConfig struct {Count *int}

type BoolFlag =FlagBase[bool,BoolConfig, boolValue]

type BoolWithInverseFlag struct {Namestring                                      `json:"name"`// name of the flagCategorystring                                      `json:"category"`// category of the flag, if anyDefaultTextstring                                      `json:"defaultText"`// default text of the flag for usage purposesHideDefaultbool                                        `json:"hideDefault"`// whether to hide the default value in outputUsagestring                                      `json:"usage"`// usage string for help outputSourcesValueSourceChain                            `json:"-"`// sources to load flag value fromRequiredbool                                        `json:"required"`// whether the flag is required or notHiddenbool                                        `json:"hidden"`// whether to hide the flag in help outputLocalbool                                        `json:"local"`// whether the flag needs to be applied to subcommands as wellValuebool                                        `json:"defaultValue"`// default value for this flag if not set by from any sourceDestination      *bool                                       `json:"-"`// destination pointer for value when setAliases          []string                                    `json:"aliases"`// Aliases that are allowed for this flagTakesFilebool                                        `json:"takesFileArg"`// whether this flag takes a file argument, mainly for shell completion purposesAction           func(context.Context, *Command,bool)error `json:"-"`// Action callback to be called when flag is setOnlyOncebool                                        `json:"onlyOnce"`// whether this flag can be duplicated on the command lineValidator        func(bool)error                            `json:"-"`// custom function to validate this flag valueValidateDefaultsbool                                        `json:"validateDefaults"`// whether to validate defaults or notConfigBoolConfig                                  `json:"config"`// Additional/Custom configuration associated with this flag typeInversePrefixstring                                      `json:"invPrefix"`// The prefix used to indicate a negative value. Default: `env` becomes `no-env`// contains filtered or unexported fields}

func (*BoolWithInverseFlag)Count¶

func (bif *BoolWithInverseFlag) Count()int

Count returns the number of times this flag has been invoked

func (*BoolWithInverseFlag)Get¶

func (bif *BoolWithInverseFlag) Get()any

func (*BoolWithInverseFlag)GetCategory¶

func (bif *BoolWithInverseFlag) GetCategory()string

GetCategory returns the category of the flag

func (*BoolWithInverseFlag)GetDefaultText¶

func (bif *BoolWithInverseFlag) GetDefaultText()string

GetDefaultText returns the default text for this flag

func (*BoolWithInverseFlag)GetEnvVars¶

func (bif *BoolWithInverseFlag) GetEnvVars() []string

GetEnvVars returns the env vars for this flag

func (*BoolWithInverseFlag)GetUsage¶

func (bif *BoolWithInverseFlag) GetUsage()string

GetUsage returns the usage string for the flag

func (*BoolWithInverseFlag)GetValue¶

func (bif *BoolWithInverseFlag) GetValue()string

GetValue returns the flags value as string representation and an emptystring if the flag takes no value at all.

func (*BoolWithInverseFlag)IsBoolFlag¶

func (bif *BoolWithInverseFlag) IsBoolFlag()bool

IsBoolFlag returns whether the flag doesnt need to accept args

func (*BoolWithInverseFlag)IsDefaultVisible¶

func (bif *BoolWithInverseFlag) IsDefaultVisible()bool

IsDefaultVisible returns true if the flag is not hidden, otherwise false

func (*BoolWithInverseFlag)IsSet¶

func (bif *BoolWithInverseFlag) IsSet()bool

func (*BoolWithInverseFlag)Names¶

func (bif *BoolWithInverseFlag) Names() []string

func (*BoolWithInverseFlag)PostParse¶

func (bif *BoolWithInverseFlag) PostParse()error

func (*BoolWithInverseFlag)PreParse¶

func (bif *BoolWithInverseFlag) PreParse()error

func (*BoolWithInverseFlag)RunAction¶

func (bif *BoolWithInverseFlag) RunAction(ctxcontext.Context, cmd *Command)error

func (*BoolWithInverseFlag)Set¶

func (bif *BoolWithInverseFlag) Set(name, valstring)error

func (*BoolWithInverseFlag)SetCategory¶

func (bif *BoolWithInverseFlag) SetCategory(cstring)

func (*BoolWithInverseFlag)String¶

func (bif *BoolWithInverseFlag) String()string

String implements the standard Stringer interface.

Example for BoolFlag{Name: "env"}--[no-]env(default: false)

func (*BoolWithInverseFlag)TakesValue¶

func (bif *BoolWithInverseFlag) TakesValue()bool

func (*BoolWithInverseFlag)TypeName¶

func (bif *BoolWithInverseFlag) TypeName()string

TypeName is used for stringify/docs. For bool its a no-op

type CategorizableFlag interface {// Returns the category of the flagGetCategory()string// Sets the category of the flagSetCategory(string)}

type Command struct {// The name of the commandNamestring `json:"name"`// A list of aliases for the commandAliases []string `json:"aliases"`// A short description of the usage of this commandUsagestring `json:"usage"`// Text to override the USAGE section of helpUsageTextstring `json:"usageText"`// A short description of the arguments of this commandArgsUsagestring `json:"argsUsage"`// Version of the commandVersionstring `json:"version"`// Longer explanation of how the command worksDescriptionstring `json:"description"`// DefaultCommand is the (optional) name of a command// to run if no command names are passed as CLI arguments.DefaultCommandstring `json:"defaultCommand"`// The category the command is part ofCategorystring `json:"category"`// List of child commandsCommands []*Command `json:"commands"`// List of flags to parseFlags []Flag `json:"flags"`// Boolean to hide built-in help command and help flagHideHelpbool `json:"hideHelp"`// Ignored if HideHelp is true.HideHelpCommandbool `json:"hideHelpCommand"`// Boolean to hide built-in version flag and the VERSION section of helpHideVersionbool `json:"hideVersion"`// Boolean to enable shell completion commandsEnableShellCompletionbool `json:"-"`// Shell Completion generation command nameShellCompletionCommandNamestring `json:"-"`// The function to call when checking for shell command completionsShellCompleteShellCompleteFunc `json:"-"`// An action to execute before any subcommands are run, but after the context is ready// If a non-nil error is returned, no subcommands are runBeforeBeforeFunc `json:"-"`// An action to execute after any subcommands are run, but after the subcommand has finished// It is run even if Action() panicsAfterAfterFunc `json:"-"`// The function to call when this command is invokedActionActionFunc `json:"-"`// Execute this function if the proper command cannot be foundCommandNotFoundCommandNotFoundFunc `json:"-"`// Execute this function if a usage error occurs.OnUsageErrorOnUsageErrorFunc `json:"-"`// Execute this function when an invalid flag is accessed from the contextInvalidFlagAccessHandlerInvalidFlagAccessFunc `json:"-"`// Boolean to hide this command from help or completionHiddenbool `json:"hidden"`// List of all authors who contributed (string or fmt.Stringer)// TODO: ~string | fmt.Stringer when interface unions are availableAuthors []any `json:"authors"`// Copyright of the binary if anyCopyrightstring `json:"copyright"`// Reader reader to write input to (useful for tests)Readerio.Reader `json:"-"`// Writer writer to write output toWriterio.Writer `json:"-"`// ErrWriter writes error outputErrWriterio.Writer `json:"-"`// ExitErrHandler processes any error encountered while running an App before// it is returned to the caller. If no function is provided, HandleExitCoder// is used as the default behavior.ExitErrHandlerExitErrHandlerFunc `json:"-"`// Other custom infoMetadata map[string]interface{} `json:"metadata"`// Carries a function which returns app specific info.ExtraInfo func() map[string]string `json:"-"`// CustomRootCommandHelpTemplate the text template for app help topic.// cli.go uses text/template to render templates. You can// render custom help text by setting this variable.CustomRootCommandHelpTemplatestring `json:"-"`// SliceFlagSeparator is used to customize the separator for SliceFlag, the default is ","SliceFlagSeparatorstring `json:"sliceFlagSeparator"`// DisableSliceFlagSeparator is used to disable SliceFlagSeparator, the default is falseDisableSliceFlagSeparatorbool `json:"disableSliceFlagSeparator"`// Boolean to enable short-option handling so user can combine several// single-character bool arguments into one// i.e. foobar -o -v -> foobar -ovUseShortOptionHandlingbool `json:"useShortOptionHandling"`// Enable suggestions for commands and flagsSuggestbool `json:"suggest"`// Allows global flags set by libraries which use flag.XXXVar(...) directly// to be parsed through this libraryAllowExtFlagsbool `json:"allowExtFlags"`// Treat all flags as normal arguments if trueSkipFlagParsingbool `json:"skipFlagParsing"`// CustomHelpTemplate the text template for the command help topic.// cli.go uses text/template to render templates. You can// render custom help text by setting this variable.CustomHelpTemplatestring `json:"-"`// Use longest prefix match for commandsPrefixMatchCommandsbool `json:"prefixMatchCommands"`// Custom suggest command for matchingSuggestCommandFuncSuggestCommandFunc `json:"-"`// Flag exclusion groupMutuallyExclusiveFlags []MutuallyExclusiveFlags `json:"mutuallyExclusiveFlags"`// Arguments to parse for this commandArguments []Argument `json:"arguments"`// Whether to read arguments from stdin// applicable to root command onlyReadArgsFromStdinbool `json:"readArgsFromStdin"`// contains filtered or unexported fields}

func (*Command)Args¶

func (cmd *Command) Args()Args

Args returns the command line arguments associated with thecommand.

func (*Command)Bool¶

func (cmd *Command) Bool(namestring)bool

func (*Command)Command¶

func (cmd *Command) Command(namestring) *Command

func (*Command)Count¶

func (cmd *Command) Count(namestring)int

Count returns the num of occurrences of this flag

func (*Command)Duration¶

func (cmd *Command) Duration(namestring)time.Duration

func (*Command)FlagNames¶

func (cmd *Command) FlagNames() []string

FlagNames returns a slice of flag names used by the this commandand all of its parent commands.

func (*Command)Float¶

func (cmd *Command) Float(namestring)float64

Float looks up the value of a local FloatFlag, returns0 if not found

func (*Command)FloatSlice¶

func (cmd *Command) FloatSlice(namestring) []float64

FloatSlice looks up the value of a local FloatSliceFlag, returnsnil if not found

func (*Command)FullName¶

func (cmd *Command) FullName()string

FullName returns the full name of the command.For commands with parents this ensures that the parent commandsare part of the command path.

func (*Command)Generic¶

func (cmd *Command) Generic(namestring)Value

Generic looks up the value of a local GenericFlag, returnsnil if not found

func (*Command)HasName¶

func (cmd *Command) HasName(namestring)bool

HasName returns true if Command.Name matches given name

func (*Command)Int¶

func (cmd *Command) Int(namestring)int64

Int looks up the value of a local Int64Flag, returns0 if not found

func (*Command)IntSlice¶

func (cmd *Command) IntSlice(namestring) []int64

IntSlice looks up the value of a local IntSliceFlag, returnsnil if not found

func (*Command)IsSet¶

func (cmd *Command) IsSet(namestring)bool

IsSet determines if the flag was actually set

func (*Command)Lineage¶

func (cmd *Command) Lineage() []*Command

Lineage returns *this* command and all of its ancestor commandsin order from child to parent

func (*Command)LocalFlagNames¶

func (cmd *Command) LocalFlagNames() []string

LocalFlagNames returns a slice of flag names used in thiscommand.

func (*Command)NArg¶

func (cmd *Command) NArg()int

NArg returns the number of the command line arguments.

func (*Command)Names¶

func (cmd *Command) Names() []string

Names returns the names including short names and aliases.

func (*Command)NumFlags¶

func (cmd *Command) NumFlags()int

NumFlags returns the number of flags set

func (*Command)Root¶

func (cmd *Command) Root() *Command

Root returns the Command at the root of the graph

func (*Command)Run¶

func (cmd *Command) Run(ctxcontext.Context, osArgs []string) (deferErrerror)

Run is the entry point to the command graph. The positionalarguments are parsed according to the Flag and Commanddefinitions and the matching Action functions are run.

package mainimport ("context""fmt""net/mail""os"cli "github.com/urfave/cli/v3")func main() {// Declare a commandcmd := &cli.Command{Name: "greet",Flags: []cli.Flag{&cli.StringFlag{Name: "name", Value: "pat", Usage: "a name to say"},},Action: func(_ context.Context, cmd *cli.Command) error {fmt.Printf("Hello %[1]v\n", cmd.String("name"))return nil},Authors: []any{&mail.Address{Name: "Oliver Allen", Address: "oliver@toyshop.example.com"},"gruffalo@soup-world.example.org",},Version: "v0.13.12",}// Simulate the command line argumentsos.Args = []string{"greet", "--name", "Jeremy"}if err := cmd.Run(context.Background(), os.Args); err != nil {// do something with unhandled errorsfmt.Fprintf(os.Stderr, "Unhandled error: %[1]v\n", err)os.Exit(86)}}

Output:Hello Jeremy

package mainimport ("context""fmt""net/mail""os""time"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:        "greet",Version:     "0.1.0",Description: "This is how we describe greet the app",Authors: []any{&mail.Address{Name: "Harrison", Address: "harrison@lolwut.example.com"},"Oliver Allen  <oliver@toyshop.example.com>",},Flags: []cli.Flag{&cli.StringFlag{Name: "name", Value: "bob", Usage: "a name to say"},},Arguments: cli.AnyArguments,Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",Description: "This is how we describe describeit the function",ArgsUsage:   "[arguments...]",Action: func(context.Context, *cli.Command) error {fmt.Printf("i like to describe things")return nil},},},}ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)defer cancel()// Simulate the command line argumentsos.Args = []string{"greet", "help"}_ = cmd.Run(ctx, os.Args)}

Output:NAME:   greet - A new cli applicationUSAGE:   greet [global options] [command [command options]] [arguments...]VERSION:   0.1.0DESCRIPTION:   This is how we describe greet the appAUTHORS:   "Harrison" <harrison@lolwut.example.com>   Oliver Allen  <oliver@toyshop.example.com>COMMANDS:   describeit, d  use it to see a description   help, h        Shows a list of commands or help for one commandGLOBAL OPTIONS:   --name string  a name to say (default: "bob")   --help, -h     show help   --version, -v  print the version

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "greet",Flags: []cli.Flag{&cli.StringFlag{Name: "name", Value: "pat", Usage: "a name to say"},},Action: func(_ context.Context, cmd *cli.Command) error {fmt.Fprintf(cmd.Root().Writer, "hello to %[1]q\n", cmd.String("name"))return nil},Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",Description: "This is how we describe describeit the function",ArgsUsage:   "[arguments...]",Action: func(context.Context, *cli.Command) error {fmt.Println("i like to describe things")return nil},},},}// Simulate the command line argumentsos.Args = []string{"greet", "h", "describeit"}_ = cmd.Run(context.Background(), os.Args)}

Output:NAME:   greet describeit - use it to see a descriptionUSAGE:   greet describeit [arguments...]DESCRIPTION:   This is how we describe describeit the functionOPTIONS:   --help, -h  show help

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "multi_values",Flags: []cli.Flag{&cli.StringMapFlag{Name: "stringMap"},},HideHelp: true,Action: func(ctx context.Context, cmd *cli.Command) error {for i, v := range cmd.FlagNames() {fmt.Printf("%d-%s %#v\n", i, v, cmd.StringMap(v))}fmt.Printf("notfound %#v\n", cmd.StringMap("notfound"))err := ctx.Err()fmt.Println("error:", err)return err},}// Simulate command line argumentsos.Args = []string{"multi_values","--stringMap", "parsed1=parsed two", "--stringMap", "parsed3=",}_ = cmd.Run(context.Background(), os.Args)}

Output:0-stringMap map[string]string{"parsed1":"parsed two", "parsed3":""}notfound map[string]string(nil)error: <nil>

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "greet"}// Simulate the command line argumentsos.Args = []string{"greet"}_ = cmd.Run(context.Background(), os.Args)}

Output:NAME:   greet - A new cli applicationUSAGE:   greet [global options]GLOBAL OPTIONS:   --help, -h  show help

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",Description: "This is how we describe describeit the function",Action: func(context.Context, *cli.Command) error {fmt.Printf("i like to describe things")return nil},}, {Name:        "next",Usage:       "next example",Description: "more stuff to see when generating shell completion",Action: func(context.Context, *cli.Command) error {fmt.Printf("the next example")return nil},},},}// Simulate a bash environment and command line argumentsos.Setenv("SHELL", "bash")os.Args = []string{"greet", "--generate-shell-completion"}_ = cmd.Run(context.Background(), os.Args)}

Output:describeitnexthelp

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Flags: []cli.Flag{&cli.IntFlag{Name:    "other",Aliases: []string{"o"},},&cli.StringFlag{Name:    "xyz",Aliases: []string{"x"},},&cli.StringFlag{Name: "some-flag,s",},&cli.StringFlag{Name: "similar-flag",},},}// Simulate a bash environment and command line argumentsos.Setenv("SHELL", "bash")os.Args = []string{"greet", "--s", "--generate-shell-completion"}_ = cmd.Run(context.Background(), os.Args)}

Output:--some-flag--similar-flag

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Flags: []cli.Flag{&cli.IntFlag{Name:    "int-flag",Aliases: []string{"i"},},&cli.StringFlag{Name:    "string",Aliases: []string{"s"},},&cli.StringFlag{Name: "string-flag-2",},&cli.StringFlag{Name: "similar-flag",},&cli.StringFlag{Name: "some-flag",},},}// Simulate a bash environment and command line argumentsos.Setenv("SHELL", "bash")os.Args = []string{"greet", "--st", "--generate-shell-completion"}_ = cmd.Run(context.Background(), os.Args)}

Output:--string--string-flag-2

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Flags: []cli.Flag{&cli.IntFlag{Name:    "other",Aliases: []string{"o"},},&cli.StringFlag{Name:    "xyz",Aliases: []string{"x"},},},}// Simulate a bash environment and command line argumentsos.Setenv("SHELL", "bash")os.Args = []string{"greet", "-", "--generate-shell-completion"}_ = cmd.Run(context.Background(), os.Args)}

Output:--other--xyz--help

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name:                  "greet",EnableShellCompletion: true,Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",Description: "This is how we describe describeit the function",Action: func(context.Context, *cli.Command) error {fmt.Printf("i like to describe things")return nil},}, {Name:        "next",Usage:       "next example",Description: "more stuff to see when generating bash completion",Action: func(context.Context, *cli.Command) error {fmt.Printf("the next example")return nil},},},}// Simulate a zsh environment and command line argumentsos.Args = []string{"greet", "--generate-shell-completion"}os.Setenv("SHELL", "/usr/bin/zsh")_ = cmd.Run(context.Background(), os.Args)}

Output:describeit:use it to see a descriptionnext:next examplehelp:Shows a list of commands or help for one command

package mainimport ("context""fmt""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "multi_values",Flags: []cli.Flag{&cli.StringSliceFlag{Name: "stringSlice"},&cli.FloatSliceFlag{Name: "float64Slice"},&cli.IntSliceFlag{Name: "intSlice"},},HideHelp: true,Action: func(ctx context.Context, cmd *cli.Command) error {for i, v := range cmd.FlagNames() {fmt.Printf("%d-%s %#v\n", i, v, cmd.Value(v))}err := ctx.Err()fmt.Println("error:", err)return err},}// Simulate command line argumentsos.Args = []string{"multi_values","--stringSlice", "parsed1,parsed2", "--stringSlice", "parsed3,parsed4","--float64Slice", "13.3,14.4", "--float64Slice", "15.5,16.6","--intSlice", "13,14", "--intSlice", "15,16",}_ = cmd.Run(context.Background(), os.Args)}

Output:0-stringSlice []string{"parsed1", "parsed2", "parsed3", "parsed4"}1-float64Slice []float64{13.3, 14.4, 15.5, 16.6}2-intSlice []int64{13, 14, 15, 16}error: <nil>

package mainimport ("context""fmt""os""time"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "say",Commands: []*cli.Command{{Name:        "hello",Aliases:     []string{"hi"},Usage:       "use it to see a description",Description: "This is how we describe hello the function",Commands: []*cli.Command{{Name:        "english",Aliases:     []string{"en"},Usage:       "sends a greeting in english",Description: "greets someone in english",Flags: []cli.Flag{&cli.StringFlag{Name:  "name",Value: "Bob",Usage: "Name of the person to greet",},},Action: func(_ context.Context, cmd *cli.Command) error {fmt.Println("Hello,", cmd.String("name"))return nil},},},},},}ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)defer cancel()// Simulate the command line argumentsos.Args = []string{"say", "hi", "english", "--name", "Jeremy"}_ = cmd.Run(ctx, os.Args)}

Output:Hello, Jeremy

package mainimport ("context""os"cli "github.com/urfave/cli/v3")func main() {cmd := &cli.Command{Name: "greet",Commands: []*cli.Command{{Name:        "describeit",Aliases:     []string{"d"},Usage:       "use it to see a description",ArgsUsage:   "[arguments...]",Description: "This is how we describe describeit the function",},},}// Simulate the command line argumentsos.Args = []string{"greet", "describeit"}_ = cmd.Run(context.Background(), os.Args)}

Output:NAME:   greet describeit - use it to see a descriptionUSAGE:   greet describeit [command [command options]] [arguments...]DESCRIPTION:   This is how we describe describeit the functionOPTIONS:   --help, -h  show help

func (*Command)Set¶

func (cmd *Command) Set(name, valuestring)error

Set sets a context flag to a value.

func (*Command)String¶

func (cmd *Command) String(namestring)string

func (*Command)StringMap¶

func (cmd *Command) StringMap(namestring) map[string]string

StringMap looks up the value of a local StringMapFlag, returnsnil if not found

func (*Command)StringSlice¶

func (cmd *Command) StringSlice(namestring) []string

StringSlice looks up the value of a local StringSliceFlag, returnsnil if not found

func (*Command)Timestamp¶

func (cmd *Command) Timestamp(namestring)time.Time

Timestamp gets the timestamp from a flag name

func (*Command)ToFishCompletion¶

func (cmd *Command) ToFishCompletion() (string,error)

ToFishCompletion creates a fish completion string for the `*App`The function errors if either parsing or writing of the string fails.

func (*Command)Uint¶

func (cmd *Command) Uint(namestring)uint64

Uint looks up the value of a local Uint64Flag, returns0 if not found

func (*Command)UintSlice¶

func (cmd *Command) UintSlice(namestring) []uint64

UintSlice looks up the value of a local UintSliceFlag, returnsnil if not found

func (*Command)Value¶

func (cmd *Command) Value(namestring) interface{}

Value returns the value of the flag corresponding to `name`

func (*Command)VisibleCategories¶

func (cmd *Command) VisibleCategories() []CommandCategory

VisibleCategories returns a slice of categories and commands that areHidden=false

func (*Command)VisibleCommands¶

func (cmd *Command) VisibleCommands() []*Command

VisibleCommands returns a slice of the Commands with Hidden=false

func (*Command)VisibleFlagCategories¶

func (cmd *Command) VisibleFlagCategories() []VisibleFlagCategory

VisibleFlagCategories returns a slice containing all the visible flag categories with the flags they contain

func (*Command)VisibleFlags¶

func (cmd *Command) VisibleFlags() []Flag

VisibleFlags returns a slice of the Flags with Hidden=false

func (*Command)VisiblePersistentFlags¶

func (cmd *Command) VisiblePersistentFlags() []Flag

VisiblePersistentFlags returns a slice ofLocalFlag with Persistent=true and Hidden=false.

type CommandCategories interface {// AddCommand adds a command to a category, creating a new category if necessary.AddCommand(categorystring, command *Command)// Categories returns a slice of categories sorted by nameCategories() []CommandCategory}

type CommandCategory interface {// Name returns the category name stringName()string// VisibleCommands returns a slice of the Commands with Hidden=falseVisibleCommands() []*Command}

type CommandNotFoundFunc func(context.Context, *Command,string)

type Countable interface {Count()int}

type DocGenerationFlag interface {// TakesValue returns true if the flag takes a value, otherwise falseTakesValue()bool// GetUsage returns the usage string for the flagGetUsage()string// GetValue returns the flags value as string representation and an empty// string if the flag takes no value at all.GetValue()string// GetDefaultText returns the default text for this flagGetDefaultText()string// GetEnvVars returns the env vars for this flagGetEnvVars() []string// IsDefaultVisible returns whether the default value should be shown in// help textIsDefaultVisible()bool// TypeName to detect if a flag is a string, bool, etc.TypeName()string}

type DocGenerationMultiValueFlag interface {DocGenerationFlag// IsMultiValueFlag returns true for flags that can be given multiple times.IsMultiValueFlag()bool}

type DurationFlag =FlagBase[time.Duration,NoConfig, durationValue]

type EnvValueSource interface {IsFromEnv()boolKey()string}

type ErrorFormatter interface {Format(sfmt.State, verbrune)}

type ExitCoder interface {errorExitCode()int}

funcExit¶

func Exit(message interface{}, exitCodeint)ExitCoder

Exit wraps a message and exit code into an error, which by default ishandled with a call to os.Exit during default error handling.

This is the simplest way to trigger a non-zero exit code for an App withouthaving to call os.Exit manually. During testing, this behavior can be avoidedby overriding the ExitErrHandler function on an App or the package-globalOsExiter function.

type ExitErrHandlerFunc func(context.Context, *Command,error)

type Flag interface {fmt.Stringer// Retrieve the value of the FlagGet()any// Lifecycle methods.// flag callback prior to parsingPreParse()error// flag callback post parsingPostParse()error// Apply Flag settings to the given flag setSet(string,string)error// All possible names for this flagNames() []string// Whether the flag has been set or notIsSet()bool}

var GenerateShellCompletionFlagFlag = &BoolFlag{Name:   "generate-shell-completion",Hidden:true,}

GenerateShellCompletionFlag enables shell completion

var HelpFlagFlag = &BoolFlag{Name:        "help",Aliases:     []string{"h"},Usage:       "show help",HideDefault:true,Local:true,}

HelpFlag prints the help for all commands and subcommands.Set to nil to disable the flag. The subcommandwill still be added unless HideHelp or HideHelpCommand is set to true.

var VersionFlagFlag = &BoolFlag{Name:        "version",Aliases:     []string{"v"},Usage:       "print the version",HideDefault:true,Local:true,}

VersionFlag prints the version for the application

type FlagBase[Tany, Cany, VCValueCreator[T, C]] struct {Namestring                                   `json:"name"`// name of the flagCategorystring                                   `json:"category"`// category of the flag, if anyDefaultTextstring                                   `json:"defaultText"`// default text of the flag for usage purposesHideDefaultbool                                     `json:"hideDefault"`// whether to hide the default value in outputUsagestring                                   `json:"usage"`// usage string for help outputSourcesValueSourceChain                         `json:"-"`// sources to load flag value fromRequiredbool                                     `json:"required"`// whether the flag is required or notHiddenbool                                     `json:"hidden"`// whether to hide the flag in help outputLocalbool                                     `json:"local"`// whether the flag needs to be applied to subcommands as wellValue            T                                        `json:"defaultValue"`// default value for this flag if not set by from any sourceDestination      *T                                       `json:"-"`// destination pointer for value when setAliases          []string                                 `json:"aliases"`// Aliases that are allowed for this flagTakesFilebool                                     `json:"takesFileArg"`// whether this flag takes a file argument, mainly for shell completion purposesAction           func(context.Context, *Command, T)error `json:"-"`// Action callback to be called when flag is setConfig           C                                        `json:"config"`// Additional/Custom configuration associated with this flag typeOnlyOncebool                                     `json:"onlyOnce"`// whether this flag can be duplicated on the command lineValidator        func(T)error                            `json:"-"`// custom function to validate this flag valueValidateDefaultsbool                                     `json:"validateDefaults"`// whether to validate defaults or not// contains filtered or unexported fields}

func (*FlagBase[T, C, VC])Count¶

func (f *FlagBase[T, C, VC]) Count()int

Count returns the number of times this flag has been invoked

func (*FlagBase[T, C, V])Get¶

func (f *FlagBase[T, C, V]) Get()any

func (*FlagBase[T, C, V])GetCategory¶

func (f *FlagBase[T, C, V]) GetCategory()string

GetCategory returns the category of the flag

func (*FlagBase[T, C, V])GetDefaultText¶

func (f *FlagBase[T, C, V]) GetDefaultText()string

GetDefaultText returns the default text for this flag

func (*FlagBase[T, C, V])GetEnvVars¶

func (f *FlagBase[T, C, V]) GetEnvVars() []string

GetEnvVars returns the env vars for this flag

func (*FlagBase[T, C, V])GetUsage¶

func (f *FlagBase[T, C, V]) GetUsage()string

GetUsage returns the usage string for the flag

func (*FlagBase[T, C, V])GetValue¶

func (f *FlagBase[T, C, V]) GetValue()string

GetValue returns the flags value as string representation and an emptystring if the flag takes no value at all.

func (*FlagBase[T, C, VC])IsBoolFlag¶

func (f *FlagBase[T, C, VC]) IsBoolFlag()bool

IsBoolFlag returns whether the flag doesnt need to accept args

func (*FlagBase[T, C, V])IsDefaultVisible¶

func (f *FlagBase[T, C, V]) IsDefaultVisible()bool

IsDefaultVisible returns true if the flag is not hidden, otherwise false

func (*FlagBase[T, C, VC])IsLocal¶

func (f *FlagBase[T, C, VC]) IsLocal()bool

IsLocal returns false if flag needs to be persistent across subcommands

func (*FlagBase[T, C, VC])IsMultiValueFlag¶

func (f *FlagBase[T, C, VC]) IsMultiValueFlag()bool

IsMultiValueFlag returns true if the value type T can take multiplevalues from cmd line. This is true for slice and map type flags

func (*FlagBase[T, C, V])IsRequired¶

func (f *FlagBase[T, C, V]) IsRequired()bool

IsRequired returns whether or not the flag is required

func (*FlagBase[T, C, V])IsSet¶

func (f *FlagBase[T, C, V]) IsSet()bool

IsSet returns whether or not the flag has been set through env or file

func (*FlagBase[T, C, V])IsVisible¶

func (f *FlagBase[T, C, V]) IsVisible()bool

IsVisible returns true if the flag is not hidden, otherwise false

func (*FlagBase[T, C, V])Names¶

func (f *FlagBase[T, C, V]) Names() []string

Names returns the names of the flag

func (*FlagBase[T, C, V])PostParse¶

func (f *FlagBase[T, C, V]) PostParse()error

PostParse populates the flag given the flag set and environment

func (*FlagBase[T, C, V])PreParse¶

func (f *FlagBase[T, C, V]) PreParse()error

func (*FlagBase[T, C, V])RunAction¶

func (f *FlagBase[T, C, V]) RunAction(ctxcontext.Context, cmd *Command)error

RunAction executes flag action if set

func (*FlagBase[T, C, V])Set¶

func (f *FlagBase[T, C, V]) Set(_string, valstring)error

Set applies given value from string

func (*FlagBase[T, C, V])SetCategory¶

func (f *FlagBase[T, C, V]) SetCategory(cstring)

func (*FlagBase[T, C, V])String¶

func (f *FlagBase[T, C, V]) String()string

String returns a readable representation of this value (for usage defaults)

func (*FlagBase[T, C, V])TakesValue¶

func (f *FlagBase[T, C, V]) TakesValue()bool

TakesValue returns true if the flag takes a value, otherwise false

func (*FlagBase[T, C, V])TypeName¶

func (f *FlagBase[T, C, V]) TypeName()string

TypeName returns the type of the flag.

type FlagCategories interface {// AddFlags adds a flag to a category, creating a new category if necessary.AddFlag(categorystring, flFlag)// VisibleCategories returns a slice of visible flag categories sorted by nameVisibleCategories() []VisibleFlagCategory}

type FlagEnvHintFunc func(envVars []string, strstring)string

var FlagEnvHinterFlagEnvHintFunc = withEnvHint

FlagEnvHinter annotates flag help message with the environment variabledetails. This is used by the default FlagStringer.

type FlagFileHintFunc func(filePath, strstring)string

var FlagFileHinterFlagFileHintFunc = withFileHint

FlagFileHinter annotates flag help message with the environment variabledetails. This is used by the default FlagStringer.

type FlagNamePrefixFunc func(fullName []string, placeholderstring)string

var FlagNamePrefixerFlagNamePrefixFunc = prefixedNames

FlagNamePrefixer converts a full flag name and its placeholder into the helpmessage flag prefix. This is used by the default FlagStringer.

type FlagStringFunc func(Flag)string

var FlagStringerFlagStringFunc = stringifyFlag

FlagStringer converts a flag definition to a string. This is used by helpto display a flag.

type FlagsByName []Flag

func (FlagsByName)Len¶

func (fFlagsByName) Len()int

func (FlagsByName)Less¶

func (fFlagsByName) Less(i, jint)bool

func (FlagsByName)Swap¶

func (fFlagsByName) Swap(i, jint)

type FloatArg =ArgumentBase[float64,NoConfig, floatValue]

type FloatFlag =FlagBase[float64,NoConfig, floatValue]

type FloatSlice =SliceBase[float64,NoConfig, floatValue]

type FloatSliceFlag =FlagBase[[]float64,NoConfig,FloatSlice]

type GenericFlag =FlagBase[Value,NoConfig, genericValue]

type IntArg =ArgumentBase[int64,IntegerConfig, intValue]

type IntFlag =FlagBase[int64,IntegerConfig, intValue]

type IntSlice =SliceBase[int64,IntegerConfig, intValue]

type IntSliceFlag =FlagBase[[]int64,IntegerConfig,IntSlice]

type IntegerConfig struct {Baseint}

type InvalidFlagAccessFunc func(context.Context, *Command,string)

type LocalFlag interface {IsLocal()bool}

type MapBase[Tany, Cany, VCValueCreator[T, C]] struct {// contains filtered or unexported fields}

funcNewMapBase¶

func NewMapBase[Tany, Cany, VCValueCreator[T, C]](defaults map[string]T) *MapBase[T, C, VC]

NewMapBase makes a *MapBase with default values

func (MapBase[T, C, VC])Create¶

func (iMapBase[T, C, VC]) Create(val map[string]T, p *map[string]T, c C)Value

func (*MapBase[T, C, VC])Get¶

func (i *MapBase[T, C, VC]) Get() interface{}

Get returns the mapping of values set by this flag

func (*MapBase[T, C, VC])Serialize¶

func (i *MapBase[T, C, VC]) Serialize()string

Serialize allows MapBase to fulfill Serializer

func (*MapBase[T, C, VC])Set¶

func (i *MapBase[T, C, VC]) Set(valuestring)error

Set parses the value and appends it to the list of values

func (*MapBase[T, C, VC])String¶

func (i *MapBase[T, C, VC]) String()string

String returns a readable representation of this value (for usage defaults)

func (MapBase[T, C, VC])ToString¶

func (iMapBase[T, C, VC]) ToString(t map[string]T)string

func (*MapBase[T, C, VC])Value¶

func (i *MapBase[T, C, VC]) Value() map[string]T

Value returns the mapping of values set by this flag

type MapSource interface {fmt.Stringerfmt.GoStringer// Lookup returns the value from the source based on key// and if it was found// or returns an empty string and falseLookup(string) (any,bool)}

funcNewMapSource¶

func NewMapSource(namestring, m map[any]any)MapSource

type MultiError interface {errorErrors() []error}

type MutuallyExclusiveFlags struct {// Flag listFlags [][]Flag// whether this group is requiredRequiredbool// Category to apply to all flags within groupCategorystring}

type NoConfig struct{}

type OnUsageErrorFunc func(ctxcontext.Context, cmd *Command, errerror, isSubcommandbool)error

type RequiredFlag interface {// whether the flag is a required flag or notIsRequired()bool}

type Serializer interface {Serialize()string}

type ShellCompleteFunc func(context.Context, *Command)

type SliceBase[Tany, Cany, VCValueCreator[T, C]] struct {// contains filtered or unexported fields}

funcNewSliceBase¶

func NewSliceBase[Tany, Cany, VCValueCreator[T, C]](defaults ...T) *SliceBase[T, C, VC]

NewSliceBase makes a *SliceBase with default values

func (SliceBase[T, C, VC])Create¶

func (iSliceBase[T, C, VC]) Create(val []T, p *[]T, c C)Value

func (*SliceBase[T, C, VC])Get¶

func (i *SliceBase[T, C, VC]) Get() interface{}

Get returns the slice of values set by this flag

func (*SliceBase[T, C, VC])Serialize¶

func (i *SliceBase[T, C, VC]) Serialize()string

Serialize allows SliceBase to fulfill Serializer

func (*SliceBase[T, C, VC])Set¶

func (i *SliceBase[T, C, VC]) Set(valuestring)error

Set parses the value and appends it to the list of values

func (*SliceBase[T, C, VC])String¶

func (i *SliceBase[T, C, VC]) String()string

String returns a readable representation of this value (for usage defaults)

func (SliceBase[T, C, VC])ToString¶

func (iSliceBase[T, C, VC]) ToString(t []T)string

func (*SliceBase[T, C, VC])Value¶

func (i *SliceBase[T, C, VC]) Value() []T

Value returns the slice of values set by this flag

type StringArg =ArgumentBase[string,StringConfig, stringValue]

type StringConfig struct {// Whether to trim whitespace of parsed valueTrimSpacebool}

type StringFlag =FlagBase[string,StringConfig, stringValue]

type StringMap =MapBase[string,StringConfig, stringValue]

type StringMapArg =ArgumentBase[map[string]string,StringConfig,StringMap]

type StringMapFlag =FlagBase[map[string]string,StringConfig,StringMap]

type StringSlice =SliceBase[string,StringConfig, stringValue]

type StringSliceFlag =FlagBase[[]string,StringConfig,StringSlice]

type SuggestCommandFunc func(commands []*Command, providedstring)string

type SuggestFlagFunc func(flags []Flag, providedstring, hideHelpbool)string

type TimestampArg =ArgumentBase[time.Time,TimestampConfig, timestampValue]

type TimestampConfig struct {Timezone *time.Location// Available layouts for flag value.//// Note that value for formats with missing year/date will be interpreted as current year/date respectively.//// Read more about time layouts:https://pkg.go.dev/time#pkg-constantsLayouts []string}

type TimestampFlag =FlagBase[time.Time,TimestampConfig, timestampValue]

type UintArg =ArgumentBase[uint64,IntegerConfig, uintValue]

type UintFlag =FlagBase[uint64,IntegerConfig, uintValue]

type UintSlice =SliceBase[uint64,IntegerConfig, uintValue]

type UintSliceFlag =FlagBase[[]uint64,IntegerConfig,UintSlice]

type Value interface {flag.Valueflag.Getter}

type ValueCreator[Tany, Cany] interface {Create(T, *T, C)ValueToString(T)string}

type ValueSource interface {fmt.Stringerfmt.GoStringer// Lookup returns the value from the source and if it was found// or returns an empty string and falseLookup() (string,bool)}

funcEnvVar¶

func EnvVar(keystring)ValueSource

funcFile¶

func File(pathstring)ValueSource

funcNewMapValueSource¶

func NewMapValueSource(keystring, msMapSource)ValueSource

type ValueSourceChain struct {Chain []ValueSource}

funcEnvVars¶

func EnvVars(keys ...string)ValueSourceChain

EnvVars is a helper function to encapsulate a number ofenvVarValueSource together as a ValueSourceChain

funcFiles¶

func Files(paths ...string)ValueSourceChain

Files is a helper function to encapsulate a number offileValueSource together as a ValueSourceChain

funcNewValueSourceChain¶

func NewValueSourceChain(src ...ValueSource)ValueSourceChain

func (*ValueSourceChain)Append¶

func (vsc *ValueSourceChain) Append(otherValueSourceChain)

func (*ValueSourceChain)EnvKeys¶

func (vsc *ValueSourceChain) EnvKeys() []string

func (*ValueSourceChain)GoString¶

func (vsc *ValueSourceChain) GoString()string

func (*ValueSourceChain)Lookup¶

func (vsc *ValueSourceChain) Lookup() (string,bool)

func (*ValueSourceChain)LookupWithSource¶

func (vsc *ValueSourceChain) LookupWithSource() (string,ValueSource,bool)

func (*ValueSourceChain)String¶

func (vsc *ValueSourceChain) String()string

type VisibleFlag interface {// IsVisible returns true if the flag is not hidden, otherwise falseIsVisible()bool}

type VisibleFlagCategory interface {// Name returns the category name stringName()string// Flags returns a slice of VisibleFlag sorted by nameFlags() []Flag}