Default subcommand when program invoked without any

[Chaitanyabsprip]

I require the following functionality, is there a way to achieve this with go-arg package?

for e.g., a program note

note dump -f ./notes.dump.md This is a new note

note -f ./notes.dump.md This is a new note

Both of the above invocation of note should behave identically.

[alexflint]

The best way would be to define the arguments for the default subcommand in the top-level struct, and process them as follows:

type dumpCommand struct {}

type someOtherCommand struct {
   // subcommand-specific arguments here
}

var args struct {
  File string `arg:"-f"`
  Dump *dumpCommand `arg:"subcommand"`
  Other *someOtherCommand `arg:"subcommand"`
}

func main() {
  arg.MustParse(&args)
  switch {
    case args.Dump != nil {
      doDump(args.File)
    case args.Other != nil {
      doOther(...)
    default:
      doDump(args.File)
  }
}

This of course means that the -f option is a "global" option available to all subcommands. If that is a concern then I could show you how to avoid that.

[Chaitanyabsprip]

The problem is the trailing arguments, I want to capture them, but positional args are not supported with subcommands in the same struct. Is there a way around that?

[Chaitanyabsprip]

To answer you query about the -f flag, it is supposed to be a global flag, but there are dump subcommand specific flags that are not global to all subcommands. For example -e is a flag that is specific to dump subcommand, which entails that it should work with the root command as well like

note -e # opens the file to edit

but the -e flag must not be valid for peek subcommand.

[alexflint]

Oh, I see. I will write a different top-level answer as I think a different approach may be warranted.

[alexflint]

One way that you could deal with this is to preprocess the raw os.Args slice like this:

var args struct {
   // normal arguments struct here
}

func main() {
  cmdline := os.Args[1:]
  if !slices.Contains(cmdline, "dump") && !slices.Contains(cmdline, "peek") && ... {
    cmdline = append([]string{"dump"}, cmdline...)
  }

  p, err := arg.NewParser(&args)
  if err != nil {
    fmt.Println(err)
    os.Exit(1)
  }
  err = p.ParseArgs(cmdline)
  if err != nil {
    p.Fail(err.Error())
  }
}

[Chaitanyabsprip]

Thanks for the quick response, I'll try it out.