internal/cli/funcs.go (1)

25-26: Add an example to the documentation.

The new FlagErrHandlerFunc would benefit from an example in the documentation, similar to how HelpFunc is documented. This would help other developers understand its usage better.

Add this documentation:

 // FlagErrHandlerFunc is executed if an error occurs while parsing flags.
+// Example:
+//
+//	func handleFlagError(ctx *Context, err error) error {
+//	  if err != nil {
+//	    fmt.Printf("Flag error: %v\n", err)
+//	  }
+//	  return err
+//	}
 type FlagErrHandlerFunc func(ctx *Context, err error) error

cli/flags/error_handler.go (1)

24-40: Optimize the nested loops with early returns.

The nested loops could be refactored for better readability and performance. Also, consider extracting the flag name check into a separate function.

Here's a suggested refactor:

-		for _, cmd := range commands {
-			for _, flag := range cmd.Flags {
-				flagNames := flag.Names()
-
-				if flag, ok := flag.(interface{ DeprecatedNames() []string }); ok {
-					flagNames = append(flagNames, flag.DeprecatedNames()...)
-				}
-
-				if !slices.Contains(flagNames, undefFlag) {
-					continue
-				}
-
-				flagName := util.FirstElement(util.RemoveEmptyElements(flag.Names()))
-
-				return errors.Errorf(flagHintFmt, undefFlag, ctx.Command.Name, cmd.Name, flagName)
-			}
-		}
+		if cmd, flag := findFlagInCommands(commands, undefFlag); cmd != nil {
+			flagName := util.FirstElement(util.RemoveEmptyElements(flag.Names()))
+			return errors.Errorf(flagHintFmt, undefFlag, ctx.Command.Name, cmd.Name, flagName)
+		}

Add this helper function:

func findFlagInCommands(commands cli.Commands, undefFlag string) (*cli.Command, cli.Flag) {
	for _, cmd := range commands {
		for _, flag := range cmd.Flags {
			flagNames := flag.Names()
			if flag, ok := flag.(interface{ DeprecatedNames() []string }); ok {
				flagNames = append(flagNames, flag.DeprecatedNames()...)
			}
			if slices.Contains(flagNames, undefFlag) {
				return cmd, flag
			}
		}
	}
	return nil, nil
}

cli/flags/flag.go (1)

54-66: Optimize slice allocation and add nil checks.

The slice handling could be more efficient, and we should add nil checks for robustness.

Here's a suggested improvement:

 func (newFlag *Flag) DeprecatedNames() []string {
-	var names []string
+	if newFlag == nil {
+		return nil
+	}
+
+	// Pre-allocate slice with estimated capacity
+	names := make([]string, 0, len(newFlag.deprecatedFlags)*2)
 
 	if flag, ok := newFlag.Flag.(interface{ DeprecatedNames() []string }); ok {
-		names = flag.DeprecatedNames()
+		names = append(names, flag.DeprecatedNames()...)
 	}
 
 	for _, deprecated := range newFlag.deprecatedFlags {
+		if deprecated == nil {
+			continue
+		}
 		names = append(names, deprecated.Names()...)
 	}
 
 	return names
 }

internal/cli/command.go (1)

77-78: Remove or complete the incomplete comment.

The comment "HandleFlagError" appears to be incomplete. Either complete the documentation or remove it to maintain code cleanliness.

-	// HandleFlagError

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

cli/flags/error_handler.go (2)

12-38: Solid error handler implementation with room for a small improvement

The error handler is well-structured and provides good suggestions. However, we could make the error type assertion more explicit for better maintainability.

Consider this small improvement:

-		var undefinedFlagErr cli.UndefinedFlagError
-		if !errors.As(err, &undefinedFlagErr) {
+		undefinedFlagErr, isUndefinedFlag := err.(cli.UndefinedFlagError)
+		if !isUndefinedFlag {

---

40-62: Consider optimizing the flag search for large command trees

The recursive flag search is well-implemented but might benefit from early returns in deeply nested command trees.

Consider adding an early return when all subcommands are searched:

 func findFlagInCommands(commands cli.Commands, undefFlag string) (cli.Commands, cli.Flag) {
+	if len(commands) == 0 {
+		return nil, nil
+	}

internal/cli/commands.go (1)

22-31: Simple and effective command names collection

The Names() method is clean and straightforward. For better memory efficiency in larger command sets, consider pre-allocating with a capacity hint.

Here's a small optimization:

-	var names = make([]string, len(commands))
+	names := make([]string, 0, len(commands))
 
 	for i, cmd := range commands {
-		names[i] = cmd.Name
+		names = append(names, cmd.Name)

test/integration_test.go (1)

121-151: Solid test implementation with room for enhancement!

The test function is well-structured using table-driven tests and proper cleanup. Consider these improvements:

1. Add more descriptive test case names instead of using array indices
2. Include additional test cases for edge scenarios like:
   • Multiple incorrect flags
   • Empty flag values
   • Invalid flag formats

Here's how you could improve the test cases:

 testCases := []struct {
+    name           string
     args          string
     expectedError error
 }{
     {
+        name: "invalid global flag raw used with init",
         args: "-raw init",
         expectedError: flags.NewGlobalFlagHintError("raw", "stack output", "raw"),
     },
     {
+        name: "invalid command flag no-include-root used with run",
         args: "run --no-include-root",
         expectedError: flags.NewCommandFlagHintError("run", "no-include-root", "catalog", "no-include-root"),
     },
+    {
+        name: "multiple invalid flags",
+        args: "run --no-include-root -raw",
+        expectedError: flags.NewCommandFlagHintError("run", "no-include-root", "catalog", "no-include-root"),
+    },
 }

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro