fix usage text and github testing action

Author: neomen

.github/workflows/test.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        go-version: ['1.24']
+        go-version: ['1.24', '1.25']
     steps:
       - uses: actions/checkout@v6
 

cli.go

@@ -5,6 +5,7 @@ import (
 	"flag"
 	"io"
 	"os"
+	"strconv"
 	"strings"
 )
 
@@ -17,6 +18,15 @@ type Group struct {
 	Title string
 }
 
+// flagMeta stores metadata about a flag that has both long and short forms.
+type flagMeta struct {
+	longName  string
+	shortName string
+	usage     string
+	value     flag.Value // the underlying flag.Value
+	defValue  string     // default value as string
+}
+
 // Command represents a CLI command with subcommands, flags, and an action.
 type Command struct {
 	// Use is the one-line usage message. Recommended syntax: "cmd [flags] [arg...]"
@@ -102,6 +112,9 @@ type Command struct {
 	// NEW fields for flag parsing results
 	parsedFlags  *flag.FlagSet // combined set used for parsing
 	leftoverArgs []string      // arguments after flag parsing
+
+	// flagMetaMap maps each flag name (both long and short) to its metadata.
+	flagMetaMap map[string]*flagMeta
 }
 
 // NewCommand creates a new command with the given name and description.
@@ -114,6 +127,7 @@ func NewCommand(use, short, long string) *Command {
 		inReader:                   os.Stdin,
 		outWriter:                  os.Stdout,
 		errWriter:                  os.Stderr,
+		flagMetaMap:                make(map[string]*flagMeta),
 	}
 	cmd.localFlags = flag.NewFlagSet(use, flag.ContinueOnError)
 	cmd.persistentFlags = flag.NewFlagSet(use, flag.ContinueOnError)
@@ -232,3 +246,71 @@ func (c *Command) persistentFlagSets() []*flag.FlagSet {
 	}
 	return sets
 }
+
+// ---------- Combined Flag Methods ----------
+
+// IntVarP defines an integer flag with both long and short names.
+// It sets the variable p to the value given on the command line.
+func (c *Command) IntVarP(p *int, long, short string, value int, usage string) {
+	// Register long flag (visible)
+	c.localFlags.IntVar(p, long, value, usage)
+	// Register short flag (hidden by skipping in help)
+	c.localFlags.IntVar(p, short, value, usage)
+	// Store metadata for help merging
+	meta := &flagMeta{
+		longName:  long,
+		shortName: short,
+		usage:     usage,
+		value:     c.localFlags.Lookup(long).Value,
+		defValue:  flagValueToString(value),
+	}
+	c.flagMetaMap[long] = meta
+	c.flagMetaMap[short] = meta
+}
+
+// StringVarP defines a string flag with both long and short names.
+func (c *Command) StringVarP(p *string, long, short string, value string, usage string) {
+	c.localFlags.StringVar(p, long, value, usage)
+	c.localFlags.StringVar(p, short, value, usage)
+	meta := &flagMeta{
+		longName:  long,
+		shortName: short,
+		usage:     usage,
+		value:     c.localFlags.Lookup(long).Value,
+		defValue:  value,
+	}
+	c.flagMetaMap[long] = meta
+	c.flagMetaMap[short] = meta
+}
+
+// BoolVarP defines a boolean flag with both long and short names.
+func (c *Command) BoolVarP(p *bool, long, short string, value bool, usage string) {
+	c.localFlags.BoolVar(p, long, value, usage)
+	c.localFlags.BoolVar(p, short, value, usage)
+	meta := &flagMeta{
+		longName:  long,
+		shortName: short,
+		usage:     usage,
+		value:     c.localFlags.Lookup(long).Value,
+		defValue:  flagValueToString(value),
+	}
+	c.flagMetaMap[long] = meta
+	c.flagMetaMap[short] = meta
+}
+
+// helper to convert a flag's default value to a string representation
+func flagValueToString(v interface{}) string {
+	switch val := v.(type) {
+	case int:
+		return strconv.Itoa(val)
+	case bool:
+		if val {
+			return "true"
+		}
+		return "false"
+	case string:
+		return val
+	default:
+		return ""
+	}
+}

help.go

@@ -43,7 +43,7 @@ func (c *Command) Help() {
 				fmt.Fprintf(w, "  %s:\n", group.Title)
 			}
 			for _, cmd := range group.Commands {
-				line := fmt.Sprintf("    %s\t%s", cmd.Name(), cmd.Short)
+				line := fmt.Sprintf("  %s\t\t%s", cmd.Name(), cmd.Short)
 				if cmd.Deprecated != "" {
 					line += " (deprecated)"
 				}
@@ -61,17 +61,63 @@ func (c *Command) usageLine() string {
 	return c.Use
 }
 
+// printFlags prints flags, merging long and short versions where defined.
 func (c *Command) printFlags(w io.Writer, fs *flag.FlagSet) {
+	// Track which flag names we've already printed as part of a combined pair
+	printed := make(map[string]bool)
+
+	// First, print combined flags
+	for _, meta := range c.flagMetaMap {
+		// We only want to print each meta once, but it's stored under two keys.
+		// Use a set of the meta pointers to avoid duplicates.
+		// For simplicity, we'll just check if we've printed the long name.
+		if printed[meta.longName] {
+			continue
+		}
+		printed[meta.longName] = true
+		printed[meta.shortName] = true
+
+		// check if empty
+		if meta.shortName == "" {
+			line := fmt.Sprintf("  --%s", meta.longName)
+			if meta.defValue != "" {
+				line += fmt.Sprintf("\t\t%s (Default: %s)", meta.usage, meta.defValue)
+			}
+			fmt.Fprintf(w, "%s\n", line)
+			continue
+		} else {
+			// check if long name is empty (should not happen in combined flags, but just in case)
+			if meta.longName == "" {
+				line := fmt.Sprintf("  -%s", meta.shortName)
+				if meta.defValue != "" {
+					line += fmt.Sprintf("\t\t%s (Default: %s)", meta.usage, meta.defValue)
+				}
+				fmt.Fprintf(w, "%s\n", line)
+				continue
+			}
+		}
+
+		// Build the flag line with both short and long names
+		line := fmt.Sprintf("  -%s, --%s", meta.shortName, meta.longName)
+		if meta.defValue != "" {
+			line += fmt.Sprintf("\t\t%s (Default: %s)", meta.usage, meta.defValue)
+		}
+		fmt.Fprintf(w, "%s\n", line)
+	}
+
+	// Then, print any remaining flags that are not part of a combined pair
 	fs.VisitAll(func(f *flag.Flag) {
-		// skip help flags to avoid duplication
 		if f.Name == "help" || f.Name == "h" {
 			return
 		}
-		fmt.Fprintf(w, "  -%s", f.Name)
+		if printed[f.Name] {
+			return
+		}
+		line := fmt.Sprintf("  -%s", f.Name)
 		if f.DefValue != "" {
-			fmt.Fprintf(w, "=%s", f.DefValue)
+			line += fmt.Sprintf("\t\t%s (Default: %s)", f.Usage, f.DefValue)
 		}
-		fmt.Fprintf(w, "\n    \t%s\n", f.Usage)
+		fmt.Fprintf(w, "%s\n    \t%s\n", line, f.Usage)
 	})
 }
 

help_test.go

@@ -31,14 +31,16 @@ func TestHelpOutput(t *testing.T) {
 		"Examples:\nexample text",
 		"Deprecated: use newcmd instead",
 		"Flags:",
-		"-flag1=default",
+		"-flag1",
+		"Default: default",
 		"flag1 usage",
 		"Persistent Flags:",
 		"-pflag",
 		"persistent flag",
 		"Available Commands:",
 		"Group One:",
-		"sub  sub short", // было "sub\tsub short"
+		"sub",
+		"sub short",
 	}
 	for _, check := range checks {
 		if !strings.Contains(out, check) {