addressing comments for dotnet subcommand

Author: aishwaryabh

src/Cli/func/Actions/LocalActions/PackAction/DotnetPackSubcommandAction.cs

@@ -10,7 +10,7 @@
 
 namespace Azure.Functions.Cli.Actions.LocalActions.PackAction
 {
-    [Action(Name = "pack dotnet", ParentCommandName = "pack", ShowInHelp = false, HelpText = ".NET specific arguments")]
+    [Action(Name = "pack dotnet", ParentCommandName = "pack", ShowInHelp = false, HelpText = "Arguments specific to .NET apps when running func pack")]
     internal class DotnetPackSubcommandAction : BaseAction
     {
         private readonly ISecretsManager _secretsManager;
@@ -31,17 +31,25 @@ public async Task RunAsync(PackOptions packOptions)
             var functionAppRoot = PackHelpers.ResolveFunctionAppRoot(packOptions.FolderPath);
             string packingRoot = functionAppRoot;
 
+            if (!Directory.Exists(functionAppRoot))
+            {
+                throw new CliException($"Directory not found to pack: {functionAppRoot}");
+            }
+
             if (packOptions.NoBuild)
             {
                 // For --no-build, treat FolderPath as the build output directory
                 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)");
+                    ColoredConsole.WriteLine(WarningColor("No folder path specified. Using current directory as build output directory."));
+                    packingRoot = Environment.CurrentDirectory;
+                }
+                else
+                {
+                    packingRoot = Path.IsPathRooted(packOptions.FolderPath)
+                        ? packOptions.FolderPath
+                        : Path.Combine(Environment.CurrentDirectory, packOptions.FolderPath);
                 }
-
-                packingRoot = Path.IsPathRooted(packOptions.FolderPath)
-                    ? packOptions.FolderPath
-                    : Path.Combine(Environment.CurrentDirectory, packOptions.FolderPath);
 
                 if (!Directory.Exists(packingRoot))
                 {
@@ -78,7 +86,7 @@ public async Task RunAsync(PackOptions packOptions)
         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.");
+            return Task.CompletedTask;
         }
 
         private void ValidateDotNetPublishDirectory(string path)
@@ -88,7 +96,7 @@ private void ValidateDotNetPublishDirectory(string path)
             {
                 if (!FileSystemHelpers.FileExists(Path.Combine(path, file)))
                 {
-                    throw new CliException($"Required file {file} not found in build output directory: {path}");
+                    throw new CliException($"Required file '{file}' not found in build output directory: {path}");
                 }
             }
         }
@@ -106,7 +114,7 @@ private async Task RunDotNetPublish(string functionAppRoot)
             }
 
             // Run dotnet publish
-            var exe = new Executable("dotnet", $"publish --configuration Release --output \"{outputPath}\"", workingDirectory: functionAppRoot);
+            var exe = new Executable("dotnet", $"publish --output \"{outputPath}\"", workingDirectory: functionAppRoot);
             var exitCode = await exe.RunAsync(
                 o => ColoredConsole.WriteLine(o),
                 e => ColoredConsole.Error.WriteLine(ErrorColor(e)));

src/Cli/func/Actions/LocalActions/PackAction/PackAction.cs

@@ -10,7 +10,7 @@
 
 namespace Azure.Functions.Cli.Actions.LocalActions.PackAction
 {
-    [Action(Name = "pack", HelpText = "Pack function app into a zip that's ready to run.", ShowInHelp = true)]
+    [Action(Name = "pack", HelpText = "Pack function app into a zip that's ready to deploy.", ShowInHelp = true)]
     internal class PackAction : BaseAction
     {
         private readonly ISecretsManager _secretsManager;
@@ -32,17 +32,18 @@ public override ICommandLineParserResult ParseArgs(string[] args)
         {
             Parser
                 .Setup<string>('o', "output")
-                .WithDescription("output path for the packed archive")
+                .WithDescription("Specifies the file path where the packed ZIP archive will be created.")
                 .Callback(o => OutputPath = o);
 
             Parser
                 .Setup<bool>("no-build")
-                .WithDescription("Skip running build for specific language if it is required")
+                .WithDescription("Do not build the project before packaging. Optionally provide a directory when func pack as the first argument that has the build contents." +
+                "Otherwise, default is the current directory.")
                 .Callback(n => NoBuild = n);
 
             Parser
                 .Setup<string>("preserve-executables")
-                .WithDescription("Comma separated list of executables to indicate which bits are to be set as executable in the zip file.")
+                .WithDescription("Comma - separated list of executable files to specify which files should be set as executable in the zip archive.")
                 .Callback(p => PreserveExecutables = p.Split(',').Select(s => s.Trim()).ToArray());
 
             if (args.Any() && !args.First().StartsWith("-"))
@@ -68,54 +69,14 @@ public override async Task RunAsync()
             };
 
             // Internally dispatch to runtime-specific subcommand
-            await RunRuntimeSpecificPack(workerRuntime, packOptions);
+            await RunRuntimeSpecificPackAsync(workerRuntime, packOptions);
         }
 
-        private async Task RunRuntimeSpecificPack(WorkerRuntime runtime, PackOptions packOptions)
-        {
-            // Internally dispatch to the appropriate subcommand handler
-            switch (runtime)
+        private async Task RunRuntimeSpecificPackAsync(WorkerRuntime runtime, PackOptions packOptions) =>
+            await (runtime switch
             {
-                case WorkerRuntime.Dotnet:
-                case WorkerRuntime.DotnetIsolated:
-                    var dotnetSubCommand = new DotnetPackSubcommandAction(_secretsManager);
-                    await dotnetSubCommand.RunAsync(packOptions);
-                    break;
-                /*
-                case WorkerRuntime.Python:
-                    var pythonSubCommand = new PythonPackSubCommand(_secretsManager, this);
-                    await pythonSubCommand.ParseAndRunAsync(args);
-                    break;
-                case WorkerRuntime.Node:
-                    var nodeSubCommand = new NodePackSubCommand(_secretsManager, this);
-                    await nodeSubCommand.ParseAndRunAsync(args);
-                    break;
-                case WorkerRuntime.Java:
-                    var javaSubCommand = new JavaPackSubCommand(_secretsManager, this);
-                    await javaSubCommand.ParseAndRunAsync(args);
-                    break;
-                case WorkerRuntime.Powershell:
-                    var powershellSubCommand = new PowerShellPackSubCommand(_secretsManager, this);
-                    await powershellSubCommand.ParseAndRunAsync(args);
-                    break;
-                */
-                default:
-                    // Keep the default behavior for now until we have created subcommands for other runtimes
-                    var functionAppRoot = PackHelpers.ResolveFunctionAppRoot(FolderPath);
-                    PackHelpers.ValidateFunctionAppRoot(functionAppRoot);
-
-                    var outputPath = PackHelpers.ResolveOutputPath(functionAppRoot, OutputPath);
-                    PackHelpers.CleanupExistingPackage(outputPath);
-
-                    if (!NoBuild)
-                    {
-                        var installExtensionAction = new InstallExtensionAction(_secretsManager, false);
-                        await installExtensionAction.RunAsync();
-                    }
-
-                    await PackHelpers.CreatePackage(functionAppRoot, outputPath, NoBuild, TelemetryCommandEvents);
-                    break;
-            }
-        }
+                WorkerRuntime.Dotnet or WorkerRuntime.DotnetIsolated => new DotnetPackSubcommandAction(_secretsManager).RunAsync(packOptions),
+                _ => throw new CliException($"Unsupported runtime: {runtime}")
+            });
     }
 }

src/Cli/func/Actions/LocalActions/PackAction/PackHelpers.cs

@@ -5,6 +5,7 @@
 using Azure.Functions.Cli.Helpers;
 using Colors.Net;
 using Microsoft.Azure.WebJobs.Script;
+using static Azure.Functions.Cli.Common.OutputTheme;
 
 namespace Azure.Functions.Cli.Actions.LocalActions.PackAction
 {
@@ -56,7 +57,7 @@ public static void CleanupExistingPackage(string outputPath)
                 }
                 catch (Exception)
                 {
-                    throw new CliException($"Could not delete {outputPath}");
+                    ColoredConsole.WriteLine(WarningColor($"Could not delete {outputPath}"));
                 }
             }
         }

src/Cli/func/Actions/LocalActions/PackAction/PackOptions.cs

@@ -1,7 +1,6 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT License. See LICENSE in the project root for license information.
 
-
 namespace Azure.Functions.Cli.Actions.LocalActions.PackAction
 {
     public class PackOptions