feat: support xor/and groups for positional arguments

Fixes #255

Extend checkMissingFlags, checkXorDuplicates, checkAndMissing, and
checkOverlappingXorAnd to include positional arguments in xor/and
group validation. Error messages now use ShortSummary() to correctly
display both flag (--flag) and positional arg names.

Author: toller892

context.go

@@ -260,7 +260,7 @@ func (c *Context) Validate() error { //nolint: gocyclo
 				return err
 			}
 		}
-		if err := checkMissingFlags(path.Flags); err != nil {
+		if err := checkMissingFlags(path.Flags, path.Positional); err != nil {
 			return err
 		}
 	}
@@ -891,13 +891,24 @@ func (c *Context) printHelp(options HelpOptions) error {
 	return c.help(options, c)
 }
 
-func checkMissingFlags(flags []*Flag) error {
+func checkMissingFlags(flags []*Flag, positional *Value) error {
 	xorGroupSet := map[string]bool{}
 	xorGroup := map[string][]string{}
 	andGroupSet := map[string]bool{}
 	andGroup := map[string][]string{}
 	missing := []string{}
 	andGroupRequired := getRequiredAndGroupMap(flags)
+
+	// Check positional arg for xor/and groups.
+	if positional != nil && positional.Set {
+		for _, xor := range positional.Tag.Xor {
+			xorGroupSet[xor] = true
+		}
+		for _, and := range positional.Tag.And {
+			andGroupSet[and] = true
+		}
+	}
+
 	for _, flag := range flags {
 		for _, and := range flag.And {
 			flag.Required = andGroupRequired[and]
@@ -1085,16 +1096,24 @@ func checkXorDuplicatedAndAndMissing(paths []*Path) error {
 
 func checkXorDuplicates(paths []*Path) error {
 	for _, path := range paths {
-		seen := map[string]*Flag{}
+		seen := map[string]*Value{}
 		for _, flag := range path.Flags {
 			if !flag.Set {
 				continue
 			}
 			for _, xor := range flag.Xor {
 				if seen[xor] != nil {
-					return fmt.Errorf("--%s and --%s can't be used together", seen[xor].Name, flag.Name)
+					return fmt.Errorf("%s and %s can't be used together", seen[xor].ShortSummary(), flag.ShortSummary())
+				}
+				seen[xor] = flag.Value
+			}
+		}
+		if path.Positional != nil && path.Positional.Set {
+			for _, xor := range path.Positional.Tag.Xor {
+				if seen[xor] != nil {
+					return fmt.Errorf("%s and %s can't be used together", seen[xor].ShortSummary(), path.Positional.ShortSummary())
 				}
-				seen[xor] = flag
+				seen[xor] = path.Positional
 			}
 		}
 	}
@@ -1104,26 +1123,31 @@ func checkXorDuplicates(paths []*Path) error {
 func checkAndMissing(paths []*Path) error {
 	for _, path := range paths {
 		missingMsgs := []string{}
-		andGroups := map[string][]*Flag{}
+		andGroups := map[string][]*Value{}
 		for _, flag := range path.Flags {
 			for _, and := range flag.And {
-				andGroups[and] = append(andGroups[and], flag)
+				andGroups[and] = append(andGroups[and], flag.Value)
+			}
+		}
+		if path.Positional != nil {
+			for _, and := range path.Positional.Tag.And {
+				andGroups[and] = append(andGroups[and], path.Positional)
 			}
 		}
-		for _, flags := range andGroups {
+		for _, values := range andGroups {
 			oneSet := false
-			notSet := []*Flag{}
-			flagNames := []string{}
-			for _, flag := range flags {
-				flagNames = append(flagNames, flag.Name)
-				if flag.Set {
+			notSet := []*Value{}
+			names := []string{}
+			for _, value := range values {
+				names = append(names, value.ShortSummary())
+				if value.Set {
 					oneSet = true
 				} else {
-					notSet = append(notSet, flag)
+					notSet = append(notSet, value)
 				}
 			}
 			if len(notSet) > 0 && oneSet {
-				missingMsgs = append(missingMsgs, fmt.Sprintf("--%s must be used together", strings.Join(flagNames, " and --")))
+				missingMsgs = append(missingMsgs, fmt.Sprintf("%s must be used together", strings.Join(names, " and ")))
 			}
 		}
 		if len(missingMsgs) > 0 {

kong.go

@@ -189,6 +189,14 @@ func checkOverlappingXorAnd(k *Kong) error {
 			andGroups[and] = append(andGroups[and], flag.Name)
 		}
 	}
+	for _, positional := range k.Model.Node.Positional {
+		for _, xor := range positional.Tag.Xor {
+			xorGroups[xor] = append(xorGroups[xor], positional.Name)
+		}
+		for _, and := range positional.Tag.And {
+			andGroups[and] = append(andGroups[and], positional.Name)
+		}
+	}
 	for xor, xorSet := range xorGroups {
 		for and, andSet := range andGroups {
 			overlappingEntries := []string{}