adding more functionality for func --help to work

Author: aishwaryabh

src/Cli/func/ActionAttribute.cs

@@ -15,5 +15,7 @@ internal sealed class ActionAttribute : Attribute
         public string HelpText { get; set; } = "placeholder";
 
         public bool ShowInHelp { get; set; } = true;
+
+        public string ParentCommandName { get; set; } = string.Empty;
     }
 }

src/Cli/func/ActionType.cs

@@ -12,5 +12,7 @@ internal class ActionType
         public IEnumerable<Context> SubContexts { get; set; }
 
         public IEnumerable<string> Names { get; set; }
+
+        public IEnumerable<string> ParentCommandName { get; set; }
     }
 }

src/Cli/func/Actions/HelpAction.cs

@@ -42,7 +42,8 @@ public HelpAction(IEnumerable<TypeAttributePair> actions, Func<Type, IAction> cr
                         Type = type,
                         Contexts = attributes.Select(a => a.Context),
                         SubContexts = attributes.Select(a => a.SubContext),
-                        Names = attributes.Select(a => a.Name)
+                        Names = attributes.Select(a => a.Name),
+                        ParentCommandName = attributes.Select(a => a.ParentCommandName)
                     };
                 });
         }
@@ -187,7 +188,8 @@ private void DisplayGeneralHelp()
                 .WriteLine("Usage: func [context] <action> [-/--options]")
                 .WriteLine();
             DisplayContextsHelp(contexts);
-            var actions = _actionTypes.Where(a => a.Contexts.Contains(Context.None));
+            var actions = _actionTypes
+                .Where(a => a.Contexts.Contains(Context.None));
             DisplayActionsHelp(actions);
         }
 
@@ -211,40 +213,88 @@ private void DisplayActionsHelp(IEnumerable<ActionType> actions)
             if (actions.Any())
             {
                 ColoredConsole.WriteLine(TitleColor("Actions: "));
+
+                // Group actions by parent command
+                var parentCommands = actions
+                    .Where(a => a.ParentCommandName.All(p => string.IsNullOrEmpty(p))) // Actions with no parent
+                    .ToList();
+
+                var subCommands = actions
+                    .Where(a => a.ParentCommandName.Any(p => !string.IsNullOrEmpty(p))) // Actions with a parent
+                    .ToList();
+
                 var longestName = actions.Select(a => a.Names).SelectMany(n => n).Max(n => n.Length);
                 longestName += 2; // for coloring chars
-                foreach (var action in actions)
+
+                // Display parent commands first
+                foreach (var parentAction in parentCommands)
                 {
-                    ColoredConsole.WriteLine(GetActionHelp(action, longestName));
-                    DisplaySwitches(action);
-                }
+                    // Display parent command
+                    ColoredConsole.WriteLine(GetActionHelp(parentAction, longestName));
+                    DisplaySwitches(parentAction);
 
-                ColoredConsole.WriteLine();
+                    // Find and display child commands for this parent
+                    var parentName = parentAction.Names.First();
+                    var childCommands = subCommands
+                        .Where(s => s.ParentCommandName.Any(p => p.Equals(parentName, StringComparison.OrdinalIgnoreCase)))
+                        .ToList();
+
+                    if (childCommands.Any())
+                    {
+                        ColoredConsole.WriteLine(); // Add spacing before subcommands
+
+                        foreach (var childCommand in childCommands)
+                        {
+                            DisplaySubCommandHelp(childCommand);
+                        }
+                    }
+
+                    ColoredConsole.WriteLine();
+                }
             }
         }
 
-        private void DisplaySwitches(ActionType actionType)
+        private void DisplaySubCommandHelp(ActionType subCommand)
+        {
+            // Extract the runtime name from the full command name
+            // E.g., "pack dotnet" -> "Dotnet"
+            var fullCommandName = subCommand.Names.First();
+            var parts = fullCommandName.Split(' ', StringSplitOptions.RemoveEmptyEntries);
+            var runtimeName = parts.Length > 1 ?
+                char.ToUpper(parts[1][0]) + parts[1].Substring(1).ToLower() :
+                fullCommandName;
+
+            var description = subCommand.Type.GetCustomAttributes<ActionAttribute>()?.FirstOrDefault()?.HelpText;
+
+            // Display indented subcommand header
+            ColoredConsole.WriteLine($"      {runtimeName.DarkCyan()}     {description}");
+
+            // Display subcommand switches with extra indentation
+            DisplaySwitches(subCommand, true);
+        }
+
+        private void DisplaySwitches(ActionType actionType, bool addExtraIndent = false)
         {
             var action = _createAction.Invoke(actionType.Type);
             try
             {
                 var options = action.ParseArgs(Array.Empty<string>());
                 if (options.UnMatchedOptions.Any())
                 {
-                    DisplayOptions(options.UnMatchedOptions);
+                    DisplayOptions(options.UnMatchedOptions, addExtraIndent);
                     ColoredConsole.WriteLine();
                 }
             }
             catch (CliArgumentsException e)
             {
                 if (e.Arguments.Any())
                 {
-                    DisplayPositionalArguments(e.Arguments);
+                    DisplayPositionalArguments(e.Arguments, addExtraIndent);
                 }
 
                 if (e.ParseResults != null && e.ParseResults.UnMatchedOptions.Any())
                 {
-                    DisplayOptions(e.ParseResults.UnMatchedOptions);
+                    DisplayOptions(e.ParseResults.UnMatchedOptions, addExtraIndent);
                 }
 
                 ColoredConsole.WriteLine();
@@ -255,13 +305,13 @@ private void DisplaySwitches(ActionType actionType)
             }
         }
 
-        private void DisplayPositionalArguments(IEnumerable<CliArgument> arguments)
+        private void DisplayPositionalArguments(IEnumerable<CliArgument> arguments, bool addExtraIndent)
         {
             var longestName = arguments.Max(o => o.Name.Length);
             longestName += 4; // 4 for coloring and <> characters
             foreach (var argument in arguments)
             {
-                var helpLine = string.Format($"    {{0, {-longestName}}} {{1}}", $"<{argument.Name}>".DarkGray(), argument.Description);
+                var helpLine = string.Format($"{(addExtraIndent ? "        " : "    ")}{{0, {-longestName}}} {{1}}", $"<{argument.Name}>".DarkGray(), argument.Description);
                 if (helpLine.Length < SafeConsole.BufferWidth)
                 {
                     ColoredConsole.WriteLine(helpLine);
@@ -277,7 +327,7 @@ private void DisplayPositionalArguments(IEnumerable<CliArgument> arguments)
             }
         }
 
-        private static void DisplayOptions(IEnumerable<ICommandLineOption> options)
+        private static void DisplayOptions(IEnumerable<ICommandLineOption> options, bool addExtraIndent = false)
         {
             var longestName = options.Max(o =>
             {
@@ -311,7 +361,7 @@ private static void DisplayOptions(IEnumerable<ICommandLineOption> options)
                     stringBuilder.Append($" [-{option.ShortName}]");
                 }
 
-                var helpSwitch = string.Format($"    {{0, {-longestName}}} ", stringBuilder.ToString().DarkGray());
+                var helpSwitch = string.Format($"{(addExtraIndent ? "        " : "    ")}{{0, {-longestName}}} ", stringBuilder.ToString().DarkGray());
                 var helpSwitchLength = helpSwitch.Length - 2; // helpSwitch contains 2 formatting characters.
                 var helpText = option.Description;
                 if (string.IsNullOrWhiteSpace(helpText))

src/Cli/func/Actions/LocalActions/PackAction/DotnetPackSubcommand.cs renamed to src/Cli/func/Actions/LocalActions/PackAction/DotnetPackSubcommandAction.cs

@@ -5,43 +5,43 @@
 using Azure.Functions.Cli.Helpers;
 using Azure.Functions.Cli.Interfaces;
 using Colors.Net;
+using Fclp;
 using static Azure.Functions.Cli.Common.OutputTheme;
 
 namespace Azure.Functions.Cli.Actions.LocalActions.PackAction
 {
-    [Action(Name = "pack dotnet", CommandType = CommandType.SubCommand, ShowInHelp = true, HelpText = "Internal .NET runtime-specific pack command")]
-    internal class DotNetPackSubCommand : PackSubCommandBase
+    [Action(Name = "pack dotnet", ParentCommandName = "pack", ShowInHelp = false, HelpText = ".NET specific arguments")]
+    internal class DotnetPackSubcommandAction : BaseAction
     {
-        public DotNetPackSubCommand(ISecretsManager secretsManager, PackAction parentAction)
-            : base(secretsManager, parentAction)
+        private readonly ISecretsManager _secretsManager;
+
+        public DotnetPackSubcommandAction(ISecretsManager secretsManager)
         {
+            _secretsManager = secretsManager;
         }
 
-        protected override void SetupParser()
+        public override ICommandLineParserResult ParseArgs(string[] args)
         {
             // .NET doesn't have any runtime-specific arguments beyond the common ones
-            Parser
-                .Setup<bool>("build-native-deps")
-                .SetDefault(false)
-                .WithDescription("Build native dependencies in Docker container");
+            return base.ParseArgs(args);
         }
 
-        public override async Task RunAsync()
+        public async Task RunAsync(PackOptions packOptions)
         {
-            var functionAppRoot = ParentAction.ResolveFunctionAppRoot();
+            var functionAppRoot = PackHelpers.ResolveFunctionAppRoot(packOptions.FolderPath);
             string packingRoot = functionAppRoot;
 
-            if (ParentAction.NoBuild)
+            if (packOptions.NoBuild)
             {
                 // For --no-build, treat FolderPath as the build output directory
-                if (string.IsNullOrEmpty(ParentAction.FolderPath))
+                if (string.IsNullOrEmpty(packOptions.FolderPath))
                 {
                     throw new CliException("When using --no-build for .NET projects, you must specify the path to the build output directory (e.g., ./bin/Release/net8.0/publish)");
                 }
 
-                packingRoot = Path.IsPathRooted(ParentAction.FolderPath)
-                    ? ParentAction.FolderPath
-                    : Path.Combine(Environment.CurrentDirectory, ParentAction.FolderPath);
+                packingRoot = Path.IsPathRooted(packOptions.FolderPath)
+                    ? packOptions.FolderPath
+                    : Path.Combine(Environment.CurrentDirectory, packOptions.FolderPath);
 
                 if (!Directory.Exists(packingRoot))
                 {
@@ -52,7 +52,7 @@ public override async Task RunAsync()
             }
             else
             {
-                ParentAction.ValidateFunctionAppRoot(functionAppRoot);
+                PackHelpers.ValidateFunctionAppRoot(functionAppRoot);
 
                 // Run dotnet publish
                 ColoredConsole.WriteLine("Building .NET project...");
@@ -62,17 +62,23 @@ public override async Task RunAsync()
                 packingRoot = Path.Combine(functionAppRoot, "output");
             }
 
-            var outputPath = ParentAction.ResolveOutputPath(functionAppRoot);
-            ParentAction.CleanupExistingPackage(outputPath);
+            var outputPath = PackHelpers.ResolveOutputPath(functionAppRoot, packOptions.OutputPath);
+            PackHelpers.CleanupExistingPackage(outputPath);
 
             // Install extensions if not in no-build mode
-            if (!ParentAction.NoBuild)
+            if (!packOptions.NoBuild)
             {
-                var installExtensionAction = new InstallExtensionAction(SecretsManager, false);
+                var installExtensionAction = new InstallExtensionAction(_secretsManager, false);
                 await installExtensionAction.RunAsync();
             }
 
-            await ParentAction.CreatePackage(packingRoot, outputPath);
+            await PackHelpers.CreatePackage(packingRoot, outputPath, packOptions.NoBuild, TelemetryCommandEvents);
+        }
+
+        public override Task RunAsync()
+        {
+            // Keep this in case the customer tries to run func pack dotnet, since this subcommand is not meant to be run directly.
+            throw new InvalidOperationException("Invalid command. Please run func pack instead with valid arguments. To see a list of valid arguments, please see func --help.");
         }
 
         private void ValidateDotNetPublishDirectory(string path)