From 95d879fc497c77479eb0f6abc064e8b69cef51fd Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Wed, 12 Nov 2025 17:17:51 -0800
Subject: [PATCH 1/4] Template Engine CLI commands: separate definitions from
 implementations

---
 .../CollectionExtensions.cs                   |  15 +
 .../CommandDefinitions/CommandDefinition.cs   | 505 ++++++++++++++++++
 .../CommandDefinitionExtensions.cs            | 119 +++++
 .../FilterOptionDefinition.cs                 |   0
 .../Commands/BaseCommand.cs                   |  80 ++-
 .../Commands/GlobalArgs.cs                    |  12 +-
 .../Commands/NewCommand.Legacy.cs             | 168 ------
 .../Commands/NewCommand.cs                    |  97 +---
 .../Commands/NewCommandArgs.cs                |   2 +-
 .../Commands/SharedOptions.cs                 |   6 +
 .../Commands/alias/AliasAddCommand.cs         |  14 +-
 .../Commands/alias/AliasCommand.cs            |  12 +-
 .../Commands/alias/AliasShowCommand.cs        |  14 +-
 .../Commands/alias/BaseAliasAddCommand.cs     |   8 +-
 .../Commands/alias/BaseAliasShowCommand.cs    |   8 +-
 .../Commands/alias/LegacyAliasAddCommand.cs   |  15 +-
 .../Commands/alias/LegacyAliasShowCommand.cs  |  14 +-
 .../create/InstantiateCommand.Help.cs         |   4 +-
 .../InstantiateCommand.NoMatchHandling.cs     |   2 +-
 .../Commands/create/InstantiateCommand.cs     |  43 +-
 .../Commands/create/InstantiateCommandArgs.cs |   4 +-
 .../Commands/details/DetailsCommand.cs        |  29 +-
 .../Commands/details/DetailsCommandArgs.cs    |   8 +-
 .../Commands/install/BaseInstallCommand.cs    |  34 +-
 .../Commands/install/InstallCommand.cs        |  11 +-
 .../Commands/install/InstallCommandArgs.cs    |  14 +-
 .../Commands/install/LegacyInstallCommand.cs  |  16 +-
 .../Commands/list/BaseListCommand.cs          |  48 +-
 .../Commands/list/LegacyListCommand.cs        |  36 +-
 .../Commands/list/ListCommand.cs              |  11 +-
 .../Commands/list/ListCommandArgs.cs          |   9 +-
 .../Commands/search/BaseSearchCommand.cs      |  43 +-
 .../Commands/search/LegacySearchCommand.cs    |  33 +-
 .../Commands/search/SearchCommand.cs          |  11 +-
 .../Commands/search/SearchCommandArgs.cs      |   6 +-
 .../uninstall/BaseUninstallCommand.cs         |  17 +-
 .../uninstall/LegacyUninstallCommand.cs       |  14 +-
 .../Commands/uninstall/UninstallCommand.cs    |  11 +-
 .../uninstall/UninstallCommandArgs.cs         |   2 +-
 .../Commands/update/BaseUpdateCommand.cs      |  21 +-
 .../update/LegacyUpdateApplyCommand.cs        |  16 +-
 .../update/LegacyUpdateCheckCommand.cs        |  18 +-
 .../Commands/update/UpdateCommand.cs          |  18 +-
 .../Commands/update/UpdateCommandArgs.cs      |   8 +-
 .../Microsoft.TemplateEngine.Cli.csproj       |   1 -
 .../NewCommandFactory.cs                      |  13 +-
 .../TemplateInvoker.cs                        |   8 +-
 .../TemplateListCoordinator.cs                |  14 +-
 .../TemplatePackageCoordinator.cs             |  20 +-
 .../TemplatePackageDisplay.cs                 |  20 +-
 .../TemplateMatchInfoExtensions.cs            |   2 +-
 .../CliTemplateSearchCoordinator.cs           |  10 +-
 .../dotnet/Commands/New/NewCommandParser.cs   |   2 +-
 .../AliasAssignmentTests.cs                   |   4 +-
 .../ParserTests/HelpTests.Resolution.cs       |  26 +-
 .../ParserTests/HelpTests.cs                  |  34 +-
 .../ParserTests/InstallTests.cs               |  28 +-
 .../InstantiateTests.NoMatchHandling.cs       |   2 +-
 .../InstantiateTests.Subcommand.cs            |  18 +-
 .../ParserTests/InstantiateTests.cs           |  32 +-
 .../ParserTests/ListTests.cs                  |  22 +-
 .../ParserTests/MiscTests.cs                  |  12 +-
 .../ParserTests/SearchTests.cs                |  32 +-
 .../TabCompletionTests.Approval.cs            |  20 +-
 .../ParserTests/TabCompletionTests.cs         |  44 +-
 .../ParserTests/TemplateCommandTests.cs       |   2 +-
 .../ParserTests/UninstallTests.cs             |  12 +-
 .../ParserTests/UpdateTests.cs                |  22 +-
 .../TemplatePackageDisplayTest.cs             |   6 +-
 .../ListTemplateResolverTests.cs              |   6 +-
 .../TemplateSearchCoordinatorTests.cs         |  20 +-
 71 files changed, 1014 insertions(+), 994 deletions(-)
 create mode 100644 src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CollectionExtensions.cs
 create mode 100644 src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinition.cs
 create mode 100644 src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinitionExtensions.cs
 rename src/Cli/Microsoft.TemplateEngine.Cli/{Commands => CommandDefinitions}/FilterOptionDefinition.cs (100%)
 delete mode 100644 src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs

diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CollectionExtensions.cs b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CollectionExtensions.cs
new file mode 100644
index 000000000000..e6fdd134c22d
--- /dev/null
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CollectionExtensions.cs
@@ -0,0 +1,15 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace Microsoft.TemplateEngine.Cli;
+
+internal static class CollectionExtensions
+{
+    public static void AddRange<T>(this ICollection<T> collection, IEnumerable<T> items)
+    {
+        foreach (T item in items)
+        {
+            collection.Add(item);
+        }
+    }
+}
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinition.cs b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinition.cs
new file mode 100644
index 000000000000..333eb9364256
--- /dev/null
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinition.cs
@@ -0,0 +1,505 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable CA1810 // Initialize reference type static fields inline
+
+using System.CommandLine;
+using Microsoft.TemplateEngine.Cli.Commands;
+
+namespace Microsoft.TemplateEngine.Cli;
+
+internal class CommandDefinition(string name, string description) : Command(name, description)
+{
+    public static class New
+    {
+        public static readonly Option<string?> DebugCustomSettingsLocationOption = new("--debug:custom-hive")
+        {
+            Description = SymbolStrings.Option_Debug_CustomSettings,
+            Hidden = true,
+            Recursive = true
+        };
+
+        public static readonly Option<bool> DebugVirtualizeSettingsOption = new("--debug:ephemeral-hive", "--debug:virtual-hive")
+        {
+            Description = SymbolStrings.Option_Debug_VirtualSettings,
+            Hidden = true,
+            Recursive = true
+        };
+
+        public static readonly Option<bool> DebugAttachOption = new("--debug:attach")
+        {
+            Description = SymbolStrings.Option_Debug_Attach,
+            Hidden = true,
+            Recursive = true
+        };
+
+        public static readonly Option<bool> DebugReinitOption = new("--debug:reinit")
+        {
+            Description = SymbolStrings.Option_Debug_Reinit,
+            Hidden = true,
+            Recursive = true
+        };
+
+        public static readonly Option<bool> DebugRebuildCacheOption = new("--debug:rebuild-cache", "--debug:rebuildcache")
+        {
+            Description = SymbolStrings.Option_Debug_RebuildCache,
+            Hidden = true,
+            Recursive = true
+        };
+
+        public static readonly Option<bool> DebugShowConfigOption = new("--debug:show-config", "--debug:showconfig")
+        {
+            Description = SymbolStrings.Option_Debug_ShowConfig,
+            Hidden = true,
+            Recursive = true
+        };
+
+        public static readonly Argument<string> ShortNameArgument = new("template-short-name")
+        {
+            Description = SymbolStrings.Command_Instantiate_Argument_ShortName,
+            Arity = new ArgumentArity(0, 1),
+            Hidden = true
+        };
+
+        public static readonly Argument<string[]> RemainingArguments = new("template-args")
+        {
+            Description = SymbolStrings.Command_Instantiate_Argument_TemplateOptions,
+            Arity = new ArgumentArity(0, 999),
+            Hidden = true
+        };
+
+        public static readonly Option<bool> InteractiveOption = SharedOptionsFactory.CreateInteractiveOption().AsHidden();
+
+        public static readonly Option<string[]> AddSourceOption = SharedOptionsFactory.CreateAddSourceOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
+
+        public static readonly Option<bool> ColumnsAllOption = SharedOptionsFactory.CreateColumnsAllOption().AsHidden();
+
+        public static readonly Option<string[]> ColumnsOption = SharedOptionsFactory.CreateColumnsOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
+
+        public static IReadOnlyList<Option> PassByOptions { get; } =
+        [
+            SharedOptions.ForceOption,
+            SharedOptions.NameOption,
+            SharedOptions.DryRunOption,
+            SharedOptions.NoUpdateCheckOption
+        ];
+
+        internal static readonly IEnumerable<Option> LegacyOptions;
+
+        private static readonly IReadOnlyDictionary<FilterOptionDefinition, Option> s_legacyFilters;
+        private static readonly Lazy<CommandDefinition> s_lazyCommand = new(Create);
+
+        static New()
+        {
+            IReadOnlyList<FilterOptionDefinition> legacyFilterDefinitions =
+            [
+                FilterOptionDefinition.AuthorFilter,
+                FilterOptionDefinition.BaselineFilter,
+                FilterOptionDefinition.LanguageFilter,
+                FilterOptionDefinition.TypeFilter,
+                FilterOptionDefinition.TagFilter,
+                FilterOptionDefinition.PackageFilter
+            ];
+
+            var filterOptionsMap = new Dictionary<FilterOptionDefinition, Option>();
+            var filterOptions = new List<Option>();
+
+            foreach (var filterDef in legacyFilterDefinitions)
+            {
+                var option = filterDef.OptionFactory().AsHidden();
+                filterOptionsMap.Add(filterDef, option);
+                filterOptions.Add(option);
+            }
+
+            LegacyOptions =
+            [
+                InteractiveOption,
+                AddSourceOption,
+                ColumnsAllOption,
+                ColumnsOption,
+                .. filterOptions,
+            ];
+
+            s_legacyFilters = filterOptionsMap;
+        }
+
+        public static CommandDefinition Command => s_lazyCommand.Value;
+
+        private static CommandDefinition Create()
+        {
+            var command = new CommandDefinition("new", SymbolStrings.Command_New_Description)
+            {
+                TreatUnmatchedTokensAsErrors = true,
+                Options =
+                {
+                    DebugCustomSettingsLocationOption,
+                    DebugVirtualizeSettingsOption,
+                    DebugAttachOption,
+                    DebugReinitOption,
+                    DebugRebuildCacheOption,
+                    DebugShowConfigOption,
+
+                    SharedOptions.OutputOption,
+                    SharedOptions.NameOption,
+                    SharedOptions.DryRunOption,
+                    SharedOptions.ForceOption,
+                    SharedOptions.NoUpdateCheckOption,
+                    SharedOptions.ProjectPathOption,
+                },
+                Arguments =
+                {
+                    ShortNameArgument,
+                    RemainingArguments,
+                },
+                Subcommands =
+                {
+                    Instantiate.Command,
+                    Install.Command,
+                    Uninstall.Command,
+                    Update.Command,
+                    Search.Command,
+                    List.Command,
+                    Alias.Command,
+                    Details.Command,
+
+                    Install.LegacyCommand,
+                    Uninstall.LegacyCommand,
+                    Update.LegacyCheckCommand,
+                    Update.LegacyApplyCommand,
+                    Search.LegacyCommand,
+                    List.LegacyCommand,
+                    Alias.Add.LegacyCommand,
+                    Alias.Show.LegacyCommand,
+                }
+            };
+
+            command.Options.AddRange(LegacyOptions);
+            return command;
+        }
+
+        internal static IReadOnlyDictionary<FilterOptionDefinition, Option> CreateFilterOptions(IEnumerable<FilterOptionDefinition> supportedFilters, bool isLegacy)
+        {
+            var filterOptionsMap = new Dictionary<FilterOptionDefinition, Option>();
+
+            foreach (var filterDef in supportedFilters)
+            {
+                filterOptionsMap.Add(filterDef, isLegacy ? s_legacyFilters[filterDef] : filterDef.OptionFactory());
+            }
+
+            return filterOptionsMap;
+        }
+    }
+
+    public static class Alias
+    {
+        public static readonly CommandDefinition Command = new("alias", SymbolStrings.Command_Alias_Description)
+        {
+            Hidden = true,
+            Subcommands =
+            {
+                Add.Command,
+                Show.Command,
+            }
+        };
+
+        public static class Add
+        {
+            public static readonly CommandDefinition Command = new("add", SymbolStrings.Command_AliasAdd_Description)
+            {
+                Hidden = true,
+            };
+
+            public static readonly CommandDefinition LegacyCommand = new("--alias", SymbolStrings.Command_AliasAdd_Description)
+            {
+                Hidden = true,
+                Aliases = { "-a" }
+            };
+        }
+
+        public static class Show
+        {
+            public static readonly CommandDefinition Command = new("show", SymbolStrings.Command_AliasShow_Description)
+            {
+                Hidden = true,
+            };
+
+            public static readonly CommandDefinition LegacyCommand = new("--show-alias", SymbolStrings.Command_AliasShow_Description)
+            {
+                Hidden = true,
+            };
+        }
+    }
+
+    public static class Instantiate
+    {
+        public static readonly Argument<string> ShortNameArgument = New.ShortNameArgument;
+        public static readonly Argument<string[]> RemainingArguments = New.RemainingArguments;
+
+        public static readonly CommandDefinition Command = new CommandDefinition("create", SymbolStrings.Command_Instantiate_Description)
+        {
+            Arguments =
+            {
+                ShortNameArgument,
+                RemainingArguments
+            },
+            Options =
+            {
+                SharedOptions.OutputOption,
+                SharedOptions.NameOption,
+                SharedOptions.DryRunOption,
+                SharedOptions.ForceOption,
+                SharedOptions.NoUpdateCheckOption,
+                SharedOptions.ProjectPathOption,
+            },
+            Validators =
+            {
+                symbolResult => symbolResult.ValidateOptionUsage(SharedOptions.OutputOption),
+                symbolResult => symbolResult.ValidateOptionUsage(SharedOptions.NameOption),
+                symbolResult => symbolResult.ValidateOptionUsage(SharedOptions.DryRunOption),
+                symbolResult => symbolResult.ValidateOptionUsage(SharedOptions.ForceOption),
+                symbolResult => symbolResult.ValidateOptionUsage(SharedOptions.NoUpdateCheckOption),
+                symbolResult => symbolResult.ValidateOptionUsage(SharedOptions.ProjectPathOption),
+            }
+        }.AddNoLegacyUsageValidators();
+    }
+
+    public static class Details
+    {
+        // Option disabled until https://github.com/dotnet/templating/issues/6811 is solved
+        //internal static Option<string> VersionOption = new("-version", "--version")
+        //{
+        //    Description = LocalizableStrings.DetailsCommand_Option_Version,
+        //    Arity = new ArgumentArity(1, 1)
+        //};
+
+        public static readonly Argument<string> NameArgument = new("package-identifier")
+        {
+            Description = LocalizableStrings.DetailsCommand_Argument_PackageIdentifier,
+            Arity = new ArgumentArity(1, 1)
+        };
+
+        public static readonly Option<bool> InteractiveOption = SharedOptions.InteractiveOption;
+        public static readonly Option<string[]> AddSourceOption = SharedOptions.AddSourceOption;
+
+        public static readonly CommandDefinition Command = new("details", SymbolStrings.Command_Details_Description)
+        {
+            Arguments =
+            {
+                NameArgument
+            },
+            Options =
+            {
+                InteractiveOption,
+                AddSourceOption,
+            }
+        };
+    }
+
+    public sealed class Install : CommandDefinition
+    {
+        public static readonly Argument<string[]> NameArgument = new("package")
+        {
+            Description = SymbolStrings.Command_Install_Argument_Package,
+            Arity = new ArgumentArity(1, 99)
+        };
+
+        public static readonly Option<bool> ForceOption =
+            SharedOptionsFactory.CreateForceOption().WithDescription(SymbolStrings.Option_Install_Force);
+
+        public static readonly Install Command = new("install", isLegacy: false);
+
+        public static readonly Install LegacyCommand = new("--install", isLegacy: true)
+        {
+            Aliases = { "-i" },
+        };
+
+        public Option<bool> InteractiveOption { get; }
+        public Option<string[]> AddSourceOption { get; }
+
+        public Install(string name, bool isLegacy)
+            : base(name, SymbolStrings.Command_Install_Description)
+        {
+            Hidden = isLegacy;
+
+            InteractiveOption = isLegacy ? New.InteractiveOption : SharedOptions.InteractiveOption;
+            AddSourceOption = isLegacy ? New.AddSourceOption : SharedOptions.AddSourceOption;
+
+            Arguments.Add(NameArgument);
+            Options.Add(InteractiveOption);
+            Options.Add(AddSourceOption);
+            Options.Add(ForceOption);
+
+            this.AddNoLegacyUsageValidators(isLegacy ? [InteractiveOption, AddSourceOption] : []);
+        }
+    }
+
+    public sealed class Uninstall : CommandDefinition
+    {
+        public static readonly Argument<string[]> NameArgument = new("package")
+        {
+            Description = SymbolStrings.Command_Uninstall_Argument_Package,
+            Arity = new ArgumentArity(0, 99)
+        };
+
+        public static readonly Uninstall Command = new("uninstall", isLegacy: false);
+
+        public static readonly Uninstall LegacyCommand = new("--uninstall", isLegacy: true)
+        {
+            Aliases = { "-u" },
+        };
+
+        public Uninstall(string name, bool isLegacy)
+            : base(name, SymbolStrings.Command_Uninstall_Description)
+        {
+            Hidden = isLegacy;
+            Arguments.Add(NameArgument);
+            this.AddNoLegacyUsageValidators();
+        }
+    }
+
+    public sealed class List : CommandDefinition
+    {
+        public static readonly IEnumerable<FilterOptionDefinition> SupportedFilters =
+        [
+            FilterOptionDefinition.AuthorFilter,
+            FilterOptionDefinition.BaselineFilter,
+            FilterOptionDefinition.LanguageFilter,
+            FilterOptionDefinition.TypeFilter,
+            FilterOptionDefinition.TagFilter
+        ];
+
+        public static readonly Argument<string> NameArgument = new("template-name")
+        {
+            Description = SymbolStrings.Command_List_Argument_Name,
+            Arity = new ArgumentArity(0, 1)
+        };
+
+        public static readonly Option<bool> IgnoreConstraintsOption = new("--ignore-constraints")
+        {
+            Description = SymbolStrings.ListCommand_Option_IgnoreConstraints,
+            Arity = ArgumentArity.Zero
+        };
+
+        public static readonly List Command = new("list", isLegacy: false);
+
+        public static readonly List LegacyCommand = new List("--list", isLegacy: true)
+        {
+            Aliases = { "-l" },
+        }.AddShortNameArgumentValidator(NameArgument);
+
+        public Option<bool> ColumnsAllOption { get; }
+        public Option<string[]> ColumnsOption { get; }
+
+        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; }
+
+        public List(string name, bool isLegacy)
+            : base(name, SymbolStrings.Command_List_Description)
+        {
+            Hidden = isLegacy;
+            ColumnsAllOption = isLegacy ? New.ColumnsAllOption : SharedOptions.ColumnsAllOption;
+            ColumnsOption = isLegacy ? New.ColumnsOption : SharedOptions.ColumnsOption;
+            Filters = New.CreateFilterOptions(SupportedFilters, isLegacy);
+
+            Arguments.Add(NameArgument);
+
+            Options.AddRange(
+            [
+                IgnoreConstraintsOption,
+                SharedOptions.OutputOption,
+                SharedOptions.ProjectPathOption,
+                ColumnsAllOption,
+                ColumnsOption,
+            ]);
+
+            Options.AddRange(Filters.Values);
+            this.AddNoLegacyUsageValidators(isLegacy ? [.. Filters.Values, ColumnsAllOption, ColumnsOption, New.ShortNameArgument] : []);
+        }
+    }
+
+    public sealed class Search : CommandDefinition
+    {
+        public static readonly IEnumerable<FilterOptionDefinition> SupportedFilters =
+        [
+            FilterOptionDefinition.AuthorFilter,
+            FilterOptionDefinition.BaselineFilter,
+            FilterOptionDefinition.LanguageFilter,
+            FilterOptionDefinition.TypeFilter,
+            FilterOptionDefinition.TagFilter,
+            FilterOptionDefinition.PackageFilter
+        ];
+
+        public static readonly Argument<string> NameArgument = new("template-name")
+        {
+            Description = SymbolStrings.Command_Search_Argument_Name,
+            Arity = new ArgumentArity(0, 1)
+        };
+
+        public static readonly Option<bool> IgnoreConstraintsOption = new("--ignore-constraints")
+        {
+            Description = SymbolStrings.ListCommand_Option_IgnoreConstraints,
+            Arity = ArgumentArity.Zero
+        };
+
+        public static readonly Search Command = new("search", isLegacy: false);
+        public static readonly Search LegacyCommand = new Search("--search", isLegacy: true).AddShortNameArgumentValidator(NameArgument);
+
+        public Option<bool> ColumnsAllOption { get; }
+        public Option<string[]> ColumnsOption { get; }
+
+        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; }
+
+        public Search(string name, bool isLegacy)
+            : base(name, SymbolStrings.Command_Search_Description)
+        {
+            Hidden = isLegacy;
+            ColumnsAllOption = isLegacy ? New.ColumnsAllOption : SharedOptions.ColumnsAllOption;
+            ColumnsOption = isLegacy ? New.ColumnsOption : SharedOptions.ColumnsOption;
+            Filters = New.CreateFilterOptions(SupportedFilters, isLegacy);
+
+            Arguments.Add(NameArgument);
+
+            Options.AddRange(
+            [
+                ColumnsAllOption,
+                ColumnsOption,
+            ]);
+
+            Options.AddRange(Filters.Values);
+            this.AddNoLegacyUsageValidators(isLegacy ? [.. Filters.Values, ColumnsAllOption, ColumnsOption, New.ShortNameArgument] : []);
+        }
+    }
+
+    public sealed class Update : CommandDefinition
+    {
+        public static readonly Option<bool> CheckOnlyOption = new("--check-only", "--dry-run")
+        {
+            Description = SymbolStrings.Command_Update_Option_CheckOnly,
+            Arity = ArgumentArity.Zero
+        };
+
+        public Option<bool> InteractiveOption { get; }
+        public Option<string[]> AddSourceOption { get; }
+
+        public Update(string name, string description, bool isLegacy)
+            : base(name, description)
+        {
+            Hidden = isLegacy;
+
+            Options.Add(InteractiveOption = isLegacy ? New.InteractiveOption : SharedOptions.InteractiveOption);
+            Options.Add(AddSourceOption = isLegacy ? New.AddSourceOption : SharedOptions.AddSourceOption);
+
+            this.AddNoLegacyUsageValidators(isLegacy ? [InteractiveOption, AddSourceOption] : []);
+        }
+
+        public static readonly Update Command = new("update", SymbolStrings.Command_Update_Description, isLegacy: false)
+        {
+            Options =
+            {
+                CheckOnlyOption,
+            }
+        };
+
+        public static readonly Update LegacyApplyCommand = new("--update-apply", SymbolStrings.Command_Update_Description, isLegacy: true);
+        public static readonly Update LegacyCheckCommand = new("--update-check", SymbolStrings.Command_Legacy_Update_Check_Description, isLegacy: true);
+    }
+}
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinitionExtensions.cs b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinitionExtensions.cs
new file mode 100644
index 000000000000..031003bef7d9
--- /dev/null
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinitionExtensions.cs
@@ -0,0 +1,119 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+#pragma warning disable SA1202 // Elements should be ordered by access
+#pragma warning disable SA1308 // Variable names should not be prefixed
+#pragma warning disable SA1311 // Static readonly fields should begin with upper-case letter
+#pragma warning disable CA1810 // Initialize reference type static fields inline
+#pragma warning disable SA1010 // Opening square brackets should be spaced correctly
+
+using System.CommandLine;
+using System.CommandLine.Parsing;
+
+namespace Microsoft.TemplateEngine.Cli;
+
+internal static class CommandDefinitionExtensions
+{
+    public static TDefinition AddShortNameArgumentValidator<TDefinition>(this TDefinition command, Argument nameArgument)
+        where TDefinition : CommandDefinition
+    {
+        command.Validators.Add(commandResult =>
+        {
+            var nameArgumentResult = commandResult.Children.FirstOrDefault(symbol => symbol is ArgumentResult argumentResult && argumentResult.Argument == nameArgument);
+            if (nameArgumentResult == null)
+            {
+                return;
+            }
+
+            ValidateArgumentUsage(commandResult, CommandDefinition.New.ShortNameArgument);
+        });
+
+        return command;
+    }
+
+    public static TDefinition AddNoLegacyUsageValidators<TDefinition>(this TDefinition command, params IEnumerable<Symbol> except)
+        where TDefinition : CommandDefinition
+    {
+        foreach (var option in CommandDefinition.New.LegacyOptions)
+        {
+            if (!except.Contains(option))
+            {
+                command.Validators.Add(symbolResult => symbolResult.ValidateOptionUsage(option));
+            }
+        }
+
+        foreach (var argument in new Argument[] { CommandDefinition.New.ShortNameArgument, CommandDefinition.New.RemainingArguments })
+        {
+            if (!except.Contains(argument))
+            {
+                command.Validators.Add(symbolResult => symbolResult.ValidateArgumentUsage(argument));
+            }
+        }
+
+        return command;
+    }
+
+    public static TDefinition AddOptions<TDefinition>(this TDefinition command, IEnumerable<Option> options)
+        where TDefinition : CommandDefinition
+    {
+        command.Options.AddRange(options);
+        return command;
+    }
+
+    internal static void ValidateArgumentUsage(this CommandResult commandResult, params Argument[] arguments)
+    {
+        if (commandResult.Parent is not CommandResult parentResult)
+        {
+            return;
+        }
+
+        List<string> wrongTokens = new();
+        foreach (Argument argument in arguments)
+        {
+            var newCommandArgument = parentResult.Children.OfType<ArgumentResult>().FirstOrDefault(result => result.Argument == argument);
+            if (newCommandArgument == null)
+            {
+                continue;
+            }
+            foreach (var token in newCommandArgument.Tokens)
+            {
+                if (!string.IsNullOrWhiteSpace(token.Value))
+                {
+                    wrongTokens.Add($"'{token.Value}'");
+                }
+            }
+        }
+        if (wrongTokens.Any())
+        {
+            //Unrecognized command or argument(s): {0}
+            commandResult.AddError(string.Format(LocalizableStrings.Commands_Validator_WrongTokens, string.Join(",", wrongTokens)));
+        }
+    }
+
+    internal static void ValidateOptionUsage(this CommandResult commandResult, Option option)
+    {
+        if (commandResult.Parent is not CommandResult parentResult)
+        {
+            return;
+        }
+
+        OptionResult? optionResult = parentResult.Children.OfType<OptionResult>().FirstOrDefault(result => result.Option == option);
+        if (optionResult != null)
+        {
+            List<string> wrongTokens = new();
+            if (optionResult.IdentifierToken is { } && !string.IsNullOrWhiteSpace(optionResult.IdentifierToken.Value))
+            {
+                wrongTokens.Add($"'{optionResult.IdentifierToken.Value}'");
+            }
+            foreach (var token in optionResult.Tokens)
+            {
+                if (token is { } t && !string.IsNullOrWhiteSpace(t.Value))
+                {
+                    wrongTokens.Add($"'{t.Value}'");
+                }
+            }
+            //Unrecognized command or argument(s): {0}
+            commandResult.AddError(string.Format(LocalizableStrings.Commands_Validator_WrongTokens, string.Join(",", wrongTokens)));
+        }
+    }
+}
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/FilterOptionDefinition.cs
similarity index 100%
rename from src/Cli/Microsoft.TemplateEngine.Cli/Commands/FilterOptionDefinition.cs
rename to src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/FilterOptionDefinition.cs
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
index 3d9db345fd6d..d43849972c60 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
@@ -17,18 +17,30 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal abstract class BaseCommand : Command
+    internal abstract class BaseCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder, CommandDefinition definition)
+        : Command(definition.Name, definition.Description)
     {
-        private readonly Func<ParseResult, ITemplateEngineHost> _hostBuilder;
-
-        protected BaseCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder,
-            string name,
-            string description)
-            : base(name, description)
+        protected static readonly Dictionary<CommandDefinition, Func<Func<ParseResult, ITemplateEngineHost>, BaseCommand>> SubcommandFactories = new()
         {
-            _hostBuilder = hostBuilder;
-        }
+            { CommandDefinition.Alias.Command, hostBuilder => new AliasCommand(hostBuilder) },
+            { CommandDefinition.Alias.Add.Command, hostBuilder => new AliasAddCommand(hostBuilder) },
+            { CommandDefinition.Alias.Add.LegacyCommand, hostBuilder => new LegacyAliasAddCommand(hostBuilder) },
+            { CommandDefinition.Alias.Show.Command, hostBuilder => new AliasShowCommand(hostBuilder) },
+            { CommandDefinition.Alias.Show.LegacyCommand, hostBuilder => new LegacyAliasShowCommand(hostBuilder) },
+            { CommandDefinition.Instantiate.Command, hostBuilder => new InstantiateCommand(hostBuilder) },
+            { CommandDefinition.Details.Command, hostBuilder => new DetailsCommand(hostBuilder) },
+            { CommandDefinition.Install.Command, hostBuilder => new InstallCommand(hostBuilder) },
+            { CommandDefinition.Install.LegacyCommand, hostBuilder => new LegacyInstallCommand(hostBuilder) },
+            { CommandDefinition.Uninstall.Command, hostBuilder => new UninstallCommand(hostBuilder) },
+            { CommandDefinition.Uninstall.LegacyCommand, hostBuilder => new LegacyUninstallCommand(hostBuilder) },
+            { CommandDefinition.List.Command, hostBuilder => new ListCommand(hostBuilder) },
+            { CommandDefinition.List.LegacyCommand, hostBuilder => new LegacyListCommand(hostBuilder) },
+            { CommandDefinition.Search.Command, hostBuilder => new SearchCommand(hostBuilder) },
+            { CommandDefinition.Search.LegacyCommand, hostBuilder => new LegacySearchCommand(hostBuilder) },
+            { CommandDefinition.Update.Command, hostBuilder => new UpdateCommand(hostBuilder) },
+            { CommandDefinition.Update.LegacyApplyCommand, hostBuilder => new LegacyUpdateApplyCommand(hostBuilder) },
+            { CommandDefinition.Update.LegacyCheckCommand, hostBuilder => new LegacyUpdateCheckCommand(hostBuilder) },
+        };
 
         protected internal virtual IEnumerable<CompletionItem> GetCompletions(CompletionContext context, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager)
         {
@@ -39,7 +51,7 @@ protected internal virtual IEnumerable<CompletionItem> GetCompletions(Completion
 
         protected IEngineEnvironmentSettings CreateEnvironmentSettings(GlobalArgs args, ParseResult parseResult)
         {
-            ITemplateEngineHost host = _hostBuilder(parseResult);
+            ITemplateEngineHost host = hostBuilder(parseResult);
             IEnvironment environment = new CliEnvironment();
 
             return new EngineEnvironmentSettings(
@@ -54,10 +66,22 @@ internal abstract class BaseCommand<TArgs> : BaseCommand where TArgs : GlobalArg
     {
         internal BaseCommand(
             Func<ParseResult, ITemplateEngineHost> hostBuilder,
-            string name,
-            string description)
-            : base(hostBuilder, name, description)
+            CommandDefinition definition)
+            : base(hostBuilder, definition)
         {
+            Hidden = definition.Hidden;
+            TreatUnmatchedTokensAsErrors = definition.TreatUnmatchedTokensAsErrors;
+
+            Aliases.AddRange(definition.Aliases);
+            Options.AddRange(definition.Options);
+            Arguments.AddRange(definition.Arguments);
+            Validators.AddRange(definition.Validators);
+
+            foreach (CommandDefinition subcommandDef in definition.Subcommands)
+            {
+                Add(SubcommandFactories[subcommandDef](hostBuilder));
+            }
+
             Action = new CommandAction(this);
         }
 
@@ -94,7 +118,7 @@ protected internal static async Task CheckTemplatesWithSubCommandName(
             }
 
             Reporter.Output.WriteLine(LocalizableStrings.Commands_TemplateShortNameCommandConflict_Info, usedCommandAlias);
-            Reporter.Output.WriteCommand(Example.For<InstantiateCommand>(args.ParseResult).WithArgument(InstantiateCommand.ShortNameArgument, usedCommandAlias));
+            Reporter.Output.WriteCommand(Example.For<InstantiateCommand>(args.ParseResult).WithArgument(CommandDefinition.New.ShortNameArgument, usedCommandAlias));
             Reporter.Output.WriteLine();
         }
 
@@ -122,32 +146,6 @@ protected static void PrintDeprecationMessage<TDepr, TNew>(ParseResult parseResu
 
         protected abstract TArgs ParseContext(ParseResult parseResult);
 
-        protected virtual Option GetFilterOption(FilterOptionDefinition def)
-        {
-            return def.OptionFactory();
-        }
-
-        protected IReadOnlyDictionary<FilterOptionDefinition, Option> SetupFilterOptions(IReadOnlyList<FilterOptionDefinition> filtersToSetup)
-        {
-            Dictionary<FilterOptionDefinition, Option> options = new();
-            foreach (FilterOptionDefinition filterDef in filtersToSetup)
-            {
-                Option newOption = GetFilterOption(filterDef);
-                Options.Add(newOption);
-                options[filterDef] = newOption;
-            }
-            return options;
-        }
-
-        /// <summary>
-        /// Adds the tabular output settings options for the command from <paramref name="command"/>.
-        /// </summary>
-        protected void SetupTabularOutputOptions(ITabularOutputCommand command)
-        {
-            Options.Add(command.ColumnsAllOption);
-            Options.Add(command.ColumnsOption);
-        }
-
         private static async Task HandleGlobalOptionsAsync(
             TArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
index 09b5e51ca77b..1b4d8eee4689 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/GlobalArgs.cs
@@ -11,12 +11,12 @@ internal class GlobalArgs : ICommandArgs
     {
         public GlobalArgs(BaseCommand command, ParseResult parseResult)
         {
-            DebugCustomSettingsLocation = parseResult.GetValue(NewCommand.DebugCustomSettingsLocationOption);
-            DebugVirtualizeSettings = parseResult.GetValue(NewCommand.DebugVirtualizeSettingsOption);
-            DebugAttach = parseResult.GetValue(NewCommand.DebugAttachOption);
-            DebugReinit = parseResult.GetValue(NewCommand.DebugReinitOption);
-            DebugRebuildCache = parseResult.GetValue(NewCommand.DebugRebuildCacheOption);
-            DebugShowConfig = parseResult.GetValue(NewCommand.DebugShowConfigOption);
+            DebugCustomSettingsLocation = parseResult.GetValue(CommandDefinition.New.DebugCustomSettingsLocationOption);
+            DebugVirtualizeSettings = parseResult.GetValue(CommandDefinition.New.DebugVirtualizeSettingsOption);
+            DebugAttach = parseResult.GetValue(CommandDefinition.New.DebugAttachOption);
+            DebugReinit = parseResult.GetValue(CommandDefinition.New.DebugReinitOption);
+            DebugRebuildCache = parseResult.GetValue(CommandDefinition.New.DebugRebuildCacheOption);
+            DebugShowConfig = parseResult.GetValue(CommandDefinition.New.DebugShowConfigOption);
             ParseResult = parseResult;
             Command = command;
             RootCommand = GetNewCommandFromParseResult(parseResult);
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs
deleted file mode 100644
index 4470c1cd82e8..000000000000
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.Legacy.cs
+++ /dev/null
@@ -1,168 +0,0 @@
-// Licensed to the .NET Foundation under one or more agreements.
-// The .NET Foundation licenses this file to you under the MIT license.
-
-using System.CommandLine;
-using System.CommandLine.Parsing;
-using Microsoft.TemplateEngine.Abstractions;
-
-namespace Microsoft.TemplateEngine.Cli.Commands
-{
-    internal partial class NewCommand : BaseCommand<NewCommandArgs>
-    {
-        private static readonly IReadOnlyList<FilterOptionDefinition> LegacyFilterDefinitions = new List<FilterOptionDefinition>()
-        {
-            FilterOptionDefinition.AuthorFilter,
-            FilterOptionDefinition.BaselineFilter,
-            FilterOptionDefinition.LanguageFilter,
-            FilterOptionDefinition.TypeFilter,
-            FilterOptionDefinition.TagFilter,
-            FilterOptionDefinition.PackageFilter
-        };
-
-        internal IEnumerable<Option> LegacyOptions
-        {
-            get
-            {
-                yield return InteractiveOption;
-                yield return AddSourceOption;
-                yield return ColumnsAllOption;
-                yield return ColumnsOption;
-                foreach (Option filter in LegacyFilters.Values)
-                {
-                    yield return filter;
-                }
-            }
-        }
-
-        internal Option<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption().AsHidden();
-
-        internal Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
-
-        internal Option<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption().AsHidden();
-
-        internal Option<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption().AsHidden().DisableAllowMultipleArgumentsPerToken();
-
-        internal IReadOnlyDictionary<FilterOptionDefinition, Option> LegacyFilters { get; private set; } = new Dictionary<FilterOptionDefinition, Option>();
-
-        internal void AddNoLegacyUsageValidators(Command command, params Symbol[] except)
-        {
-            IEnumerable<Option> optionsToVerify = LegacyFilters.Values.Concat(new Option[] { ColumnsAllOption, ColumnsOption, InteractiveOption, AddSourceOption });
-            IEnumerable<Argument> argumentsToVerify = new Argument[] { ShortNameArgument, RemainingArguments };
-
-            foreach (Option option in optionsToVerify)
-            {
-                if (!except.Contains(option))
-                {
-                    command.Validators.Add(symbolResult => ValidateOptionUsage(symbolResult, option));
-                }
-            }
-
-            foreach (Argument argument in argumentsToVerify)
-            {
-                if (!except.Contains(argument))
-                {
-                    command.Validators.Add(symbolResult => ValidateArgumentUsage(symbolResult, argument));
-                }
-            }
-        }
-
-        internal void ValidateShortNameArgumentIsNotUsed(CommandResult commandResult)
-        {
-            ValidateArgumentUsage(commandResult, ShortNameArgument);
-        }
-
-        internal void ValidateArgumentsAreNotUsed(CommandResult commandResult)
-        {
-            ValidateArgumentUsage(commandResult, ShortNameArgument, RemainingArguments);
-        }
-
-        internal void ValidateOptionUsage(CommandResult commandResult, Option option)
-        {
-            if (commandResult.Parent is not CommandResult parentResult)
-            {
-                return;
-            }
-
-            OptionResult? optionResult = parentResult.Children.OfType<OptionResult>().FirstOrDefault(result => result.Option == option);
-            if (optionResult != null)
-            {
-                List<string> wrongTokens = new();
-                if (optionResult.IdentifierToken is { } && !string.IsNullOrWhiteSpace(optionResult.IdentifierToken.Value))
-                {
-                    wrongTokens.Add($"'{optionResult.IdentifierToken.Value}'");
-                }
-                foreach (var token in optionResult.Tokens)
-                {
-                    if (token is { } t && !string.IsNullOrWhiteSpace(t.Value))
-                    {
-                        wrongTokens.Add($"'{t.Value}'");
-                    }
-                }
-                //Unrecognized command or argument(s): {0}
-                commandResult.AddError(string.Format(LocalizableStrings.Commands_Validator_WrongTokens, string.Join(",", wrongTokens)));
-            }
-        }
-
-        private static void ValidateArgumentUsage(CommandResult commandResult, params Argument[] arguments)
-        {
-            if (commandResult.Parent is not CommandResult parentResult)
-            {
-                return;
-            }
-
-            List<string> wrongTokens = new();
-            foreach (Argument argument in arguments)
-            {
-                var newCommandArgument = parentResult.Children.OfType<ArgumentResult>().FirstOrDefault(result => result.Argument == argument);
-                if (newCommandArgument == null)
-                {
-                    continue;
-                }
-                foreach (var token in newCommandArgument.Tokens)
-                {
-                    if (!string.IsNullOrWhiteSpace(token.Value))
-                    {
-                        wrongTokens.Add($"'{token.Value}'");
-                    }
-                }
-            }
-            if (wrongTokens.Any())
-            {
-                //Unrecognized command or argument(s): {0}
-                commandResult.AddError(string.Format(LocalizableStrings.Commands_Validator_WrongTokens, string.Join(",", wrongTokens)));
-            }
-        }
-
-        private void BuildLegacySymbols(Func<ParseResult, ITemplateEngineHost> hostBuilder)
-        {
-            Arguments.Add(ShortNameArgument);
-            Arguments.Add(RemainingArguments);
-
-            //legacy options
-            Dictionary<FilterOptionDefinition, Option> options = new();
-            foreach (var filterDef in LegacyFilterDefinitions)
-            {
-                options[filterDef] = filterDef.OptionFactory().AsHidden();
-                Options.Add(options[filterDef]);
-            }
-            LegacyFilters = options;
-
-            Options.Add(InteractiveOption);
-            Options.Add(AddSourceOption);
-            Options.Add(ColumnsAllOption);
-            Options.Add(ColumnsOption);
-
-            TreatUnmatchedTokensAsErrors = true;
-
-            Add(new LegacyInstallCommand(this, hostBuilder));
-            Add(new LegacyUninstallCommand(this, hostBuilder));
-            Add(new LegacyUpdateCheckCommand(this, hostBuilder));
-            Add(new LegacyUpdateApplyCommand(this, hostBuilder));
-            Add(new LegacySearchCommand(this, hostBuilder));
-            Add(new LegacyListCommand(this, hostBuilder));
-            Add(new LegacyAliasAddCommand(hostBuilder));
-            Add(new LegacyAliasShowCommand(hostBuilder));
-        }
-    }
-}
-
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs
index e8883d6a9f6f..2de6254f533b 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommand.cs
@@ -11,105 +11,12 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal partial class NewCommand : BaseCommand<NewCommandArgs>, ICustomHelp
     {
-        internal NewCommand(
-            string commandName,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, commandName, SymbolStrings.Command_New_Description)
+        internal NewCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+            : base(hostBuilder, CommandDefinition.New.Command)
         {
             this.DocsLink = "https://aka.ms/dotnet-new";
-            TreatUnmatchedTokensAsErrors = true;
-
-            //it is important that legacy commands are built before non-legacy, as non legacy commands are building validators that rely on legacy stuff
-            BuildLegacySymbols(hostBuilder);
-
-            Add(new InstantiateCommand(this, hostBuilder));
-            Add(new InstallCommand(this, hostBuilder));
-            Add(new UninstallCommand(this, hostBuilder));
-            Add(new UpdateCommand(this, hostBuilder));
-            Add(new SearchCommand(this, hostBuilder));
-            Add(new ListCommand(this, hostBuilder));
-            Add(new AliasCommand(hostBuilder));
-            Add(new DetailsCommand(hostBuilder));
-
-            Options.Add(DebugCustomSettingsLocationOption);
-            Options.Add(DebugVirtualizeSettingsOption);
-            Options.Add(DebugAttachOption);
-            Options.Add(DebugReinitOption);
-            Options.Add(DebugRebuildCacheOption);
-            Options.Add(DebugShowConfigOption);
-
-            Options.Add(SharedOptions.OutputOption);
-            Options.Add(SharedOptions.NameOption);
-            Options.Add(SharedOptions.DryRunOption);
-            Options.Add(SharedOptions.ForceOption);
-            Options.Add(SharedOptions.NoUpdateCheckOption);
-            Options.Add(SharedOptions.ProjectPathOption);
         }
 
-        internal static Option<string?> DebugCustomSettingsLocationOption { get; } = new("--debug:custom-hive")
-        {
-            Description = SymbolStrings.Option_Debug_CustomSettings,
-            Hidden = true,
-            Recursive = true
-        };
-
-        internal static Option<bool> DebugVirtualizeSettingsOption { get; } = new("--debug:ephemeral-hive", "--debug:virtual-hive")
-        {
-            Description = SymbolStrings.Option_Debug_VirtualSettings,
-            Hidden = true,
-            Recursive = true
-        };
-
-        internal static Option<bool> DebugAttachOption { get; } = new("--debug:attach")
-        {
-            Description = SymbolStrings.Option_Debug_Attach,
-            Hidden = true,
-            Recursive = true
-        };
-
-        internal static Option<bool> DebugReinitOption { get; } = new("--debug:reinit")
-        {
-            Description = SymbolStrings.Option_Debug_Reinit,
-            Hidden = true,
-            Recursive = true
-        };
-
-        internal static Option<bool> DebugRebuildCacheOption { get; } = new("--debug:rebuild-cache", "--debug:rebuildcache")
-        {
-            Description = SymbolStrings.Option_Debug_RebuildCache,
-            Hidden = true,
-            Recursive = true
-        };
-
-        internal static Option<bool> DebugShowConfigOption { get; } = new("--debug:show-config", "--debug:showconfig")
-        {
-            Description = SymbolStrings.Option_Debug_ShowConfig,
-            Hidden = true,
-            Recursive = true
-        };
-
-        internal static Argument<string> ShortNameArgument { get; } = new("template-short-name")
-        {
-            Description = SymbolStrings.Command_Instantiate_Argument_ShortName,
-            Arity = new ArgumentArity(0, 1),
-            Hidden = true
-        };
-
-        internal static Argument<string[]> RemainingArguments { get; } = new("template-args")
-        {
-            Description = SymbolStrings.Command_Instantiate_Argument_TemplateOptions,
-            Arity = new ArgumentArity(0, 999),
-            Hidden = true
-        };
-
-        internal IReadOnlyList<Option> PassByOptions { get; } = new Option[]
-        {
-            SharedOptions.ForceOption,
-            SharedOptions.NameOption,
-            SharedOptions.DryRunOption,
-            SharedOptions.NoUpdateCheckOption
-        };
-
         protected internal override IEnumerable<CompletionItem> GetCompletions(CompletionContext context, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager)
         {
             if (context is not TextCompletionContext textCompletionContext)
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommandArgs.cs
index 212fd2eb03df..4467e4b30a27 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/NewCommandArgs.cs
@@ -20,7 +20,7 @@ public NewCommandArgs(NewCommand command, ParseResult parseResult) : base(comman
                     {
                         continue;
                     }
-                    if (!command.LegacyOptions.Contains(o.Option) && !command.PassByOptions.Contains(o.Option))
+                    if (!CommandDefinition.New.LegacyOptions.Contains(o.Option) && !CommandDefinition.New.PassByOptions.Contains(o.Option))
                     {
                         continue;
                     }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs
index e9963f51aa21..6ccb56df9ac9 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs
@@ -21,6 +21,12 @@ public static class SharedOptions
 
         public static Option<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption();
 
+        public static Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
+
+        public static Option<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption();
+
+        public static Option<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption();
+
         internal static Option<bool> ForceOption { get; } = SharedOptionsFactory.CreateForceOption();
 
         internal static Option<string> NameOption { get; } = new("--name", "-n")
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasAddCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasAddCommand.cs
index 13a5a919dae6..e2965b2ff325 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasAddCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasAddCommand.cs
@@ -4,15 +4,9 @@
 using System.CommandLine;
 using Microsoft.TemplateEngine.Abstractions;
 
-namespace Microsoft.TemplateEngine.Cli.Commands
+namespace Microsoft.TemplateEngine.Cli.Commands;
+
+internal sealed class AliasAddCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+    : BaseAliasAddCommand(hostBuilder, CommandDefinition.Alias.Add.Command)
 {
-    internal class AliasAddCommand : BaseAliasAddCommand
-    {
-        internal AliasAddCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, "add")
-        {
-            Hidden = true;
-        }
-    }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasCommand.cs
index 5a277c3defe1..99957d36a64c 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasCommand.cs
@@ -7,17 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class AliasCommand : BaseCommand<AliasCommandArgs>
+    internal sealed class AliasCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseCommand<AliasCommandArgs>(hostBuilder, CommandDefinition.Alias.Command)
     {
-        internal AliasCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, "alias", SymbolStrings.Command_Alias_Description)
-        {
-            Hidden = true;
-            Add(new AliasAddCommand(hostBuilder));
-            Add(new AliasShowCommand(hostBuilder));
-        }
-
         protected override Task<NewCommandStatus> ExecuteAsync(
             AliasCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasShowCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasShowCommand.cs
index 983f7105d364..ceb49e194613 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasShowCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/AliasShowCommand.cs
@@ -4,15 +4,9 @@
 using System.CommandLine;
 using Microsoft.TemplateEngine.Abstractions;
 
-namespace Microsoft.TemplateEngine.Cli.Commands
+namespace Microsoft.TemplateEngine.Cli.Commands;
+
+internal sealed class AliasShowCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+    : BaseAliasShowCommand(hostBuilder, CommandDefinition.Alias.Show.Command)
 {
-    internal class AliasShowCommand : BaseAliasShowCommand
-    {
-        internal AliasShowCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, "show")
-        {
-            Hidden = true;
-        }
-    }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasAddCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasAddCommand.cs
index 120275d0ce99..d258b652c958 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasAddCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasAddCommand.cs
@@ -7,13 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class BaseAliasAddCommand : BaseCommand<AliasAddCommandArgs>
+    internal class BaseAliasAddCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder, CommandDefinition definition)
+        : BaseCommand<AliasAddCommandArgs>(hostBuilder, definition)
     {
-        internal BaseAliasAddCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder,
-            string commandName)
-            : base(hostBuilder, commandName, SymbolStrings.Command_AliasAdd_Description) { }
-
         protected override Task<NewCommandStatus> ExecuteAsync(
             AliasAddCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasShowCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasShowCommand.cs
index e389dd60e645..34b3a212d967 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasShowCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/BaseAliasShowCommand.cs
@@ -7,13 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class BaseAliasShowCommand : BaseCommand<AliasShowCommandArgs>
+    internal abstract class BaseAliasShowCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder, CommandDefinition definition)
+        : BaseCommand<AliasShowCommandArgs>(hostBuilder, definition)
     {
-        internal BaseAliasShowCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder,
-            string commandName)
-            : base(hostBuilder, commandName, SymbolStrings.Command_AliasShow_Description) { }
-
         protected override Task<NewCommandStatus> ExecuteAsync(
             AliasShowCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasAddCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasAddCommand.cs
index 941b39f0e7b4..afc9ad5e6e1a 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasAddCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasAddCommand.cs
@@ -4,16 +4,9 @@
 using System.CommandLine;
 using Microsoft.TemplateEngine.Abstractions;
 
-namespace Microsoft.TemplateEngine.Cli.Commands
+namespace Microsoft.TemplateEngine.Cli.Commands;
+
+internal sealed class LegacyAliasAddCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+    : BaseAliasAddCommand(hostBuilder, CommandDefinition.Alias.Add.LegacyCommand)
 {
-    internal class LegacyAliasAddCommand : BaseAliasAddCommand
-    {
-        internal LegacyAliasAddCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, "--alias")
-        {
-            Aliases.Add("-a");
-            Hidden = true;
-        }
-    }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasShowCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasShowCommand.cs
index bbacbfd550b4..0fae30896379 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasShowCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/alias/LegacyAliasShowCommand.cs
@@ -4,15 +4,9 @@
 using System.CommandLine;
 using Microsoft.TemplateEngine.Abstractions;
 
-namespace Microsoft.TemplateEngine.Cli.Commands
+namespace Microsoft.TemplateEngine.Cli.Commands;
+
+internal sealed class LegacyAliasShowCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+    : BaseAliasShowCommand(hostBuilder, CommandDefinition.Alias.Show.LegacyCommand)
 {
-    internal class LegacyAliasShowCommand : BaseAliasShowCommand
-    {
-        internal LegacyAliasShowCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, "--show-alias")
-        {
-            Hidden = true;
-        }
-    }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.Help.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.Help.cs
index a4c7278d5759..69d5a82fa19a 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.Help.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.Help.cs
@@ -216,7 +216,7 @@ internal static void ShowHintForOtherTemplates(TemplateGroup templateGroup, CliT
             writer.WriteLine(
                 Example
                     .For<NewCommand>(args.ParseResult)
-                    .WithArgument(NewCommand.ShortNameArgument, templateGroup.ShortNames[0])
+                    .WithArgument(CommandDefinition.New.ShortNameArgument, templateGroup.ShortNames[0])
                     .WithHelpOption()
                     .WithOption(SharedOptionsFactory.CreateLanguageOption(), supportedLanguages.First())
                     .ToString().Indent());
@@ -251,7 +251,7 @@ internal static void ShowHintForOtherTemplates(TemplateGroup templateGroup, CliT
             writer.WriteLine(HelpStrings.Hint_HelpForOtherTypes, string.Join(", ", supportedTypes));
             writer.WriteLine(Example
                 .For<NewCommand>(args.ParseResult)
-                .WithArgument(NewCommand.ShortNameArgument, templateGroup.ShortNames[0])
+                .WithArgument(CommandDefinition.New.ShortNameArgument, templateGroup.ShortNames[0])
                 .WithHelpOption()
                 .WithOption(SharedOptionsFactory.CreateTypeOption(), supportedTypes.First())
                 .ToString().Indent());
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.NoMatchHandling.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.NoMatchHandling.cs
index a9612bfb0c49..f015a60ba4e8 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.NoMatchHandling.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.NoMatchHandling.cs
@@ -153,7 +153,7 @@ private static NewCommandStatus HandleNoTemplateFoundResult(
                 reporter.WriteLine(LocalizableStrings.InvalidParameterTemplateHint);
                 var example = Example
                     .For<NewCommand>(args.ParseResult)
-                    .WithArgument(NewCommand.ShortNameArgument, templateGroup.ShortNames[0]);
+                    .WithArgument(CommandDefinition.New.ShortNameArgument, templateGroup.ShortNames[0]);
                 var language = matchInfos.Where(mi => mi.Language != null).FirstOrDefault()?.Language;
                 if (language != null)
                 {
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
index 7889716ea67b..31e4afcb0efa 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommand.cs
@@ -15,42 +15,11 @@ namespace Microsoft.TemplateEngine.Cli.Commands
 {
     internal partial class InstantiateCommand : BaseCommand<InstantiateCommandArgs>, ICustomHelp
     {
-        internal InstantiateCommand(
-            NewCommand parentCommand,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, "create", SymbolStrings.Command_Instantiate_Description)
+        internal InstantiateCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+            : base(hostBuilder, CommandDefinition.Instantiate.Command)
         {
-            Arguments.Add(ShortNameArgument);
-            Arguments.Add(RemainingArguments);
-
-            Options.Add(SharedOptions.OutputOption);
-            Options.Add(SharedOptions.NameOption);
-            Options.Add(SharedOptions.DryRunOption);
-            Options.Add(SharedOptions.ForceOption);
-            Options.Add(SharedOptions.NoUpdateCheckOption);
-            Options.Add(SharedOptions.ProjectPathOption);
-
-            parentCommand.AddNoLegacyUsageValidators(this);
-            Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.OutputOption));
-            Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.NameOption));
-            Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.DryRunOption));
-            Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.ForceOption));
-            Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.NoUpdateCheckOption));
-            Validators.Add(symbolResult => parentCommand.ValidateOptionUsage(symbolResult, SharedOptions.ProjectPathOption));
         }
 
-        internal static Argument<string> ShortNameArgument { get; } = new Argument<string>("template-short-name")
-        {
-            Description = SymbolStrings.Command_Instantiate_Argument_ShortName,
-            Arity = new ArgumentArity(0, 1)
-        };
-
-        internal Argument<string[]> RemainingArguments { get; } = new Argument<string[]>("template-args")
-        {
-            Description = SymbolStrings.Command_Instantiate_Argument_TemplateOptions,
-            Arity = new ArgumentArity(0, 999)
-        };
-
         internal IReadOnlyList<Option> PassByOptions { get; } = new Option[]
         {
             SharedOptions.ForceOption,
@@ -466,8 +435,8 @@ private static void SuggestTypoCorrections(InstantiateCommandArgs instantiateArg
                 foreach (string possibleMatch in possibleTemplateMatches)
                 {
                     Example example = useInstantiateCommand
-                        ? Example.For<InstantiateCommand>(instantiateArgs.ParseResult).WithArgument(ShortNameArgument, possibleMatch)
-                        : Example.For<NewCommand>(instantiateArgs.ParseResult).WithArgument(NewCommand.ShortNameArgument, possibleMatch);
+                        ? Example.For<InstantiateCommand>(instantiateArgs.ParseResult).WithArgument(CommandDefinition.New.ShortNameArgument, possibleMatch)
+                        : Example.For<NewCommand>(instantiateArgs.ParseResult).WithArgument(CommandDefinition.New.ShortNameArgument, possibleMatch);
                     if (helpOption)
                     {
                         example = example.WithHelpOption();
@@ -512,7 +481,7 @@ private static void WriteListCommandExample(InstantiateCommandArgs instantiateAr
                   Example
                       .For<NewCommand>(instantiateArgs.ParseResult)
                       .WithSubcommand<ListCommand>()
-                      .WithArgument(BaseListCommand.NameArgument, instantiateArgs.ShortName));
+                      .WithArgument(CommandDefinition.List.NameArgument, instantiateArgs.ShortName));
             }
             else
             {
@@ -533,7 +502,7 @@ private static void WriteSearchCommandExample(InstantiateCommandArgs instantiate
                     Example
                         .For<NewCommand>(instantiateArgs.ParseResult)
                         .WithSubcommand<SearchCommand>()
-                        .WithArgument(BaseSearchCommand.NameArgument, instantiateArgs.ShortName));
+                        .WithArgument(CommandDefinition.Search.NameArgument, instantiateArgs.ShortName));
             }
         }
     }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommandArgs.cs
index 15a5a05bddca..3db5bf3f3be9 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/create/InstantiateCommandArgs.cs
@@ -10,8 +10,8 @@ internal class InstantiateCommandArgs : GlobalArgs
     {
         public InstantiateCommandArgs(InstantiateCommand command, ParseResult parseResult) : base(command, parseResult)
         {
-            RemainingArguments = parseResult.GetValue(command.RemainingArguments) ?? Array.Empty<string>();
-            ShortName = parseResult.GetValue(InstantiateCommand.ShortNameArgument);
+            RemainingArguments = parseResult.GetValue(CommandDefinition.Instantiate.RemainingArguments) ?? Array.Empty<string>();
+            ShortName = parseResult.GetValue(CommandDefinition.Instantiate.ShortNameArgument);
 
             var tokens = new List<string>();
             if (!string.IsNullOrWhiteSpace(ShortName))
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommand.cs
index 31224d978541..cd16381df3a9 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommand.cs
@@ -8,34 +8,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class DetailsCommand : BaseCommand<DetailsCommandArgs>
+    internal sealed class DetailsCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseCommand<DetailsCommandArgs>(hostBuilder, CommandDefinition.Details.Command)
     {
-        internal DetailsCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, "details", SymbolStrings.Command_Details_Description)
-        {
-            Arguments.Add(NameArgument);
-            Options.Add(InteractiveOption);
-            Options.Add(AddSourceOption);
-        }
-
-        internal static Argument<string> NameArgument { get; } = new("package-identifier")
-        {
-            Description = LocalizableStrings.DetailsCommand_Argument_PackageIdentifier,
-            Arity = new ArgumentArity(1, 1)
-        };
-
-        // Option disabled until https://github.com/dotnet/templating/issues/6811 is solved
-        //internal static Option<string> VersionOption { get; } = new("-version", "--version")
-        //{
-        //    Description = LocalizableStrings.DetailsCommand_Option_Version,
-        //    Arity = new ArgumentArity(1, 1)
-        //};
-
-        internal virtual Option<bool> InteractiveOption { get; } = SharedOptions.InteractiveOption;
-
-        internal virtual Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
-
         protected override async Task<NewCommandStatus> ExecuteAsync(
             DetailsCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommandArgs.cs
index 73442829b820..7e9a0587dc54 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/details/DetailsCommandArgs.cs
@@ -9,13 +9,13 @@ internal class DetailsCommandArgs : GlobalArgs
     {
         internal DetailsCommandArgs(DetailsCommand detailsCommand, ParseResult parseResult) : base(detailsCommand, parseResult)
         {
-            string nameCriteria = parseResult.GetValue(DetailsCommand.NameArgument)
-                ?? throw new ArgumentException($"{nameof(parseResult)} should contain one argument for {nameof(DetailsCommand.NameArgument)}", nameof(parseResult));
+            string nameCriteria = parseResult.GetValue(CommandDefinition.Details.NameArgument)
+                ?? throw new ArgumentException($"{nameof(parseResult)} should contain one argument for {CommandDefinition.Details.NameArgument.Name}", nameof(parseResult));
 
             NameCriteria = nameCriteria;
             VersionCriteria = null;
-            Interactive = parseResult.GetValue(detailsCommand.InteractiveOption);
-            AdditionalSources = parseResult.GetValue(detailsCommand.AddSourceOption);
+            Interactive = parseResult.GetValue(CommandDefinition.Details.InteractiveOption);
+            AdditionalSources = parseResult.GetValue(CommandDefinition.Details.AddSourceOption);
         }
 
         internal bool Interactive { get; }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs
index b3821ebed5d1..8118dd0f0f7d 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/BaseInstallCommand.cs
@@ -7,34 +7,10 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal abstract class BaseInstallCommand : BaseCommand<InstallCommandArgs>
+    internal abstract class BaseInstallCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder, CommandDefinition.Install definition)
+        : BaseCommand<InstallCommandArgs>(hostBuilder, definition)
     {
-        internal BaseInstallCommand(
-            NewCommand parentCommand,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder,
-            string commandName)
-            : base(hostBuilder, commandName, SymbolStrings.Command_Install_Description)
-        {
-            ParentCommand = parentCommand;
-            Arguments.Add(NameArgument);
-            Options.Add(InteractiveOption);
-            Options.Add(AddSourceOption);
-            Options.Add(ForceOption);
-        }
-
-        internal static Argument<string[]> NameArgument { get; } = new("package")
-        {
-            Description = SymbolStrings.Command_Install_Argument_Package,
-            Arity = new ArgumentArity(1, 99)
-        };
-
-        internal static Option<bool> ForceOption { get; } = SharedOptionsFactory.CreateForceOption().WithDescription(SymbolStrings.Option_Install_Force);
-
-        internal virtual Option<bool> InteractiveOption { get; } = SharedOptions.InteractiveOption;
-
-        internal virtual Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
-
-        protected NewCommand ParentCommand { get; }
+        public CommandDefinition.Install Definition => definition;
 
         protected override Task<NewCommandStatus> ExecuteAsync(
             InstallCommandArgs args,
@@ -48,8 +24,6 @@ protected override Task<NewCommandStatus> ExecuteAsync(
         }
 
         protected override InstallCommandArgs ParseContext(ParseResult parseResult)
-        {
-            return new InstallCommandArgs(this, parseResult);
-        }
+            => new(this, parseResult);
     }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommand.cs
index 4e359f47ac98..429239006679 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommand.cs
@@ -7,16 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class InstallCommand : BaseInstallCommand
+    internal sealed class InstallCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseInstallCommand(hostBuilder, CommandDefinition.Install.Command)
     {
-        public InstallCommand(
-                NewCommand parentCommand,
-                Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(parentCommand, hostBuilder, "install")
-        {
-            parentCommand.AddNoLegacyUsageValidators(this);
-        }
-
         protected override async Task<NewCommandStatus> ExecuteAsync(
             InstallCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommandArgs.cs
index 4c136ea17ace..6003f784d621 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/InstallCommandArgs.cs
@@ -9,13 +9,13 @@ internal class InstallCommandArgs : GlobalArgs
     {
         public InstallCommandArgs(BaseInstallCommand installCommand, ParseResult parseResult) : base(installCommand, parseResult)
         {
-            var nameResult = parseResult.GetResult(BaseInstallCommand.NameArgument);
+            var nameResult = parseResult.GetResult(CommandDefinition.Install.NameArgument);
             if (nameResult is null || nameResult.Errors.Any())
             {
-                throw new ArgumentException($"{nameof(parseResult)} should contain at least one argument for {nameof(BaseInstallCommand.NameArgument)}", nameof(parseResult));
+                throw new ArgumentException($"{nameof(parseResult)} should contain at least one argument for {CommandDefinition.Install.NameArgument.Name}", nameof(parseResult));
             }
 
-            TemplatePackages = parseResult.GetValue(BaseInstallCommand.NameArgument)!;
+            TemplatePackages = parseResult.GetValue(CommandDefinition.Install.NameArgument)!;
 
             //workaround for --install source1 --install source2 case
             if (installCommand is LegacyInstallCommand && (TemplatePackages.Contains(installCommand.Name) || installCommand.Aliases.Any(alias => TemplatePackages.Contains(alias))))
@@ -25,12 +25,12 @@ public InstallCommandArgs(BaseInstallCommand installCommand, ParseResult parseRe
 
             if (!TemplatePackages.Any())
             {
-                throw new ArgumentException($"{nameof(parseResult)} should contain at least one argument for {nameof(BaseInstallCommand.NameArgument)}", nameof(parseResult));
+                throw new ArgumentException($"{nameof(parseResult)} should contain at least one argument for {CommandDefinition.Install.NameArgument.Name}", nameof(parseResult));
             }
 
-            Interactive = parseResult.GetValue(installCommand.InteractiveOption);
-            AdditionalSources = parseResult.GetValue(installCommand.AddSourceOption);
-            Force = parseResult.GetValue(BaseInstallCommand.ForceOption);
+            Interactive = parseResult.GetValue(installCommand.Definition.InteractiveOption);
+            AdditionalSources = parseResult.GetValue(installCommand.Definition.AddSourceOption);
+            Force = parseResult.GetValue(CommandDefinition.Install.ForceOption);
         }
 
         public IReadOnlyList<string> TemplatePackages { get; }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs
index 3d7688e5dab1..95cff84a2792 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/install/LegacyInstallCommand.cs
@@ -7,21 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class LegacyInstallCommand : BaseInstallCommand
+    internal sealed class LegacyInstallCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseInstallCommand(hostBuilder, CommandDefinition.Install.LegacyCommand)
     {
-        public LegacyInstallCommand(NewCommand parentCommand, Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(parentCommand, hostBuilder, "--install")
-        {
-            Hidden = true;
-            Aliases.Add("-i");
-
-            parentCommand.AddNoLegacyUsageValidators(this, except: new Option[] { InteractiveOption, AddSourceOption });
-        }
-
-        internal override Option<bool> InteractiveOption => ParentCommand.InteractiveOption;
-
-        internal override Option<string[]> AddSourceOption => ParentCommand.AddSourceOption;
-
         protected override Task<NewCommandStatus> ExecuteAsync(InstallCommandArgs args, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, ParseResult parseResult, CancellationToken cancellationToken)
         {
             PrintDeprecationMessage<LegacyInstallCommand, InstallCommand>(args.ParseResult);
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs
index 79c3ad8fe7b1..bbd370f27484 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/BaseListCommand.cs
@@ -7,52 +7,23 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class BaseListCommand : BaseCommand<ListCommandArgs>, IFilterableCommand, ITabularOutputCommand
+    internal abstract class BaseListCommand : BaseCommand<ListCommandArgs>, IFilterableCommand, ITabularOutputCommand
     {
-        internal static readonly IReadOnlyList<FilterOptionDefinition> SupportedFilters = new List<FilterOptionDefinition>()
-        {
-            FilterOptionDefinition.AuthorFilter,
-            FilterOptionDefinition.BaselineFilter,
-            FilterOptionDefinition.LanguageFilter,
-            FilterOptionDefinition.TypeFilter,
-            FilterOptionDefinition.TagFilter
-        };
+        private readonly CommandDefinition.List _definition;
 
         internal BaseListCommand(
-            NewCommand parentCommand,
             Func<ParseResult, ITemplateEngineHost> hostBuilder,
-            string commandName)
-            : base(hostBuilder, commandName, SymbolStrings.Command_List_Description)
+            CommandDefinition.List definition)
+            : base(hostBuilder, definition)
         {
-            ParentCommand = parentCommand;
-            Filters = SetupFilterOptions(SupportedFilters);
-
-            Arguments.Add(NameArgument);
-            Options.Add(IgnoreConstraintsOption);
-            Options.Add(SharedOptions.OutputOption);
-            Options.Add(SharedOptions.ProjectPathOption);
-            SetupTabularOutputOptions(this);
+            _definition = definition;
         }
 
-        public virtual Option<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption();
-
-        public virtual Option<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption();
-
-        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; protected set; }
+        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters => _definition.Filters;
 
-        internal static Option<bool> IgnoreConstraintsOption { get; } = new("--ignore-constraints")
-        {
-            Description = SymbolStrings.ListCommand_Option_IgnoreConstraints,
-            Arity = ArgumentArity.Zero
-        };
-
-        internal static Argument<string> NameArgument { get; } = new("template-name")
-        {
-            Description = SymbolStrings.Command_List_Argument_Name,
-            Arity = new ArgumentArity(0, 1)
-        };
+        public Option<bool> ColumnsAllOption => _definition.ColumnsAllOption;
 
-        internal NewCommand ParentCommand { get; }
+        public Option<string[]> ColumnsOption => _definition.ColumnsOption;
 
         protected override Task<NewCommandStatus> ExecuteAsync(
             ListCommandArgs args,
@@ -69,7 +40,8 @@ protected override Task<NewCommandStatus> ExecuteAsync(
             return templateListCoordinator.DisplayTemplateGroupListAsync(args, cancellationToken);
         }
 
-        protected override ListCommandArgs ParseContext(ParseResult parseResult) => new(this, parseResult);
+        protected override ListCommandArgs ParseContext(ParseResult parseResult)
+            => new(this, parseResult);
 
     }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs
index 348f3eff3bc3..ddb0d81458e8 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/LegacyListCommand.cs
@@ -2,50 +2,18 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 using Microsoft.TemplateEngine.Edge.Settings;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class LegacyListCommand : BaseListCommand
+    internal class LegacyListCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseListCommand(hostBuilder, CommandDefinition.List.LegacyCommand)
     {
-        public LegacyListCommand(
-            NewCommand parentCommand,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(parentCommand, hostBuilder, "--list")
-        {
-            Hidden = true;
-            Aliases.Add("-l");
-            Validators.Add(ValidateParentCommandArguments);
-
-            parentCommand.AddNoLegacyUsageValidators(this, except: Filters.Values.Concat(new Symbol[] { ColumnsAllOption, ColumnsOption, NewCommand.ShortNameArgument }).ToArray());
-        }
-
-        public override Option<bool> ColumnsAllOption => ParentCommand.ColumnsAllOption;
-
-        public override Option<string[]> ColumnsOption => ParentCommand.ColumnsOption;
-
-        protected override Option GetFilterOption(FilterOptionDefinition def)
-        {
-            return ParentCommand.LegacyFilters[def];
-        }
-
         protected override Task<NewCommandStatus> ExecuteAsync(ListCommandArgs args, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, ParseResult parseResult, CancellationToken cancellationToken)
         {
             PrintDeprecationMessage<LegacyListCommand, ListCommand>(args.ParseResult);
             return base.ExecuteAsync(args, environmentSettings, templatePackageManager, parseResult, cancellationToken);
         }
-
-        private void ValidateParentCommandArguments(CommandResult commandResult)
-        {
-            var nameArgumentResult = commandResult.Children.FirstOrDefault(
-                symbol => symbol is ArgumentResult argumentResult && argumentResult.Argument == NameArgument);
-            if (nameArgumentResult == null)
-            {
-                return;
-            }
-            ParentCommand.ValidateShortNameArgumentIsNotUsed(commandResult);
-        }
     }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/ListCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/ListCommand.cs
index 59175f6813e9..4d0062fdd3df 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/ListCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/ListCommand.cs
@@ -7,16 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class ListCommand : BaseListCommand
+    internal sealed class ListCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseListCommand(hostBuilder, CommandDefinition.List.Command)
     {
-        public ListCommand(
-                NewCommand parentCommand,
-                Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(parentCommand, hostBuilder, "list")
-        {
-            parentCommand.AddNoLegacyUsageValidators(this);
-        }
-
         protected override async Task<NewCommandStatus> ExecuteAsync(
             ListCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/ListCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/ListCommandArgs.cs
index 1e206c31f756..274f6ece4115 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/ListCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/list/ListCommandArgs.cs
@@ -9,26 +9,27 @@ internal class ListCommandArgs : BaseFilterableArgs, ITabularOutputArgs
     {
         internal ListCommandArgs(BaseListCommand command, ParseResult parseResult) : base(command, parseResult)
         {
-            string? nameCriteria = parseResult.GetValue(BaseListCommand.NameArgument);
+            string? nameCriteria = parseResult.GetValue(CommandDefinition.List.NameArgument);
             if (!string.IsNullOrWhiteSpace(nameCriteria))
             {
                 ListNameCriteria = nameCriteria;
             }
             // for legacy case new command argument is also accepted
-            else if (command is LegacyListCommand legacySearchCommand)
+            else if (command is LegacyListCommand)
             {
-                string? newCommandArgument = parseResult.GetValue(NewCommand.ShortNameArgument);
+                string? newCommandArgument = parseResult.GetValue(CommandDefinition.New.ShortNameArgument);
                 if (!string.IsNullOrWhiteSpace(newCommandArgument))
                 {
                     ListNameCriteria = newCommandArgument;
                 }
             }
             (DisplayAllColumns, ColumnsToDisplay) = ParseTabularOutputSettings(command, parseResult);
+
             if (AppliedFilters.Contains(FilterOptionDefinition.LanguageFilter))
             {
                 Language = GetFilterValue(FilterOptionDefinition.LanguageFilter);
             }
-            IgnoreConstraints = parseResult.GetValue(BaseListCommand.IgnoreConstraintsOption);
+            IgnoreConstraints = parseResult.GetValue(CommandDefinition.List.IgnoreConstraintsOption);
         }
 
         public bool DisplayAllColumns { get; }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs
index 25d52fc404cf..17d0123ef342 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/BaseSearchCommand.cs
@@ -8,44 +8,21 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class BaseSearchCommand : BaseCommand<SearchCommandArgs>, IFilterableCommand, ITabularOutputCommand
+    internal abstract class BaseSearchCommand : BaseCommand<SearchCommandArgs>, IFilterableCommand, ITabularOutputCommand
     {
-        internal static readonly IReadOnlyList<FilterOptionDefinition> SupportedFilters = new List<FilterOptionDefinition>()
-        {
-            FilterOptionDefinition.AuthorFilter,
-            FilterOptionDefinition.BaselineFilter,
-            FilterOptionDefinition.LanguageFilter,
-            FilterOptionDefinition.TypeFilter,
-            FilterOptionDefinition.TagFilter,
-            FilterOptionDefinition.PackageFilter
-        };
+        private readonly CommandDefinition.Search _definition;
 
-        internal BaseSearchCommand(
-            NewCommand parentCommand,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder,
-            string commandName)
-            : base(hostBuilder, commandName, SymbolStrings.Command_Search_Description)
+        internal BaseSearchCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder, CommandDefinition.Search definition)
+            : base(hostBuilder, definition)
         {
-            ParentCommand = parentCommand;
-            Filters = SetupFilterOptions(SupportedFilters);
-
-            Arguments.Add(NameArgument);
-            SetupTabularOutputOptions(this);
+            _definition = definition;
         }
 
-        public virtual Option<bool> ColumnsAllOption { get; } = SharedOptionsFactory.CreateColumnsAllOption();
+        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters => _definition.Filters;
 
-        public virtual Option<string[]> ColumnsOption { get; } = SharedOptionsFactory.CreateColumnsOption();
+        public Option<bool> ColumnsAllOption => _definition.ColumnsAllOption;
 
-        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; protected set; }
-
-        internal static Argument<string> NameArgument { get; } = new("template-name")
-        {
-            Description = SymbolStrings.Command_Search_Argument_Name,
-            Arity = new ArgumentArity(0, 1)
-        };
-
-        internal NewCommand ParentCommand { get; }
+        public Option<string[]> ColumnsOption => _definition.ColumnsOption;
 
         protected override Task<NewCommandStatus> ExecuteAsync(
             SearchCommandArgs args,
@@ -63,8 +40,6 @@ protected override Task<NewCommandStatus> ExecuteAsync(
         }
 
         protected override SearchCommandArgs ParseContext(ParseResult parseResult)
-        {
-            return new SearchCommandArgs(this, parseResult);
-        }
+            => new(this, parseResult);
     }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs
index 9c7ad1f2d7fc..f359bd942069 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/LegacySearchCommand.cs
@@ -2,47 +2,18 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 
 using System.CommandLine;
-using System.CommandLine.Parsing;
 using Microsoft.TemplateEngine.Abstractions;
 using Microsoft.TemplateEngine.Edge.Settings;
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class LegacySearchCommand : BaseSearchCommand
+    internal sealed class LegacySearchCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseSearchCommand(hostBuilder, CommandDefinition.Search.LegacyCommand)
     {
-        public LegacySearchCommand(NewCommand parentCommand, Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(parentCommand, hostBuilder, "--search")
-        {
-            Hidden = true;
-            Validators.Add(ValidateParentCommandArguments);
-
-            parentCommand.AddNoLegacyUsageValidators(this, except: Filters.Values.Concat(new Symbol[] { ColumnsAllOption, ColumnsOption, NewCommand.ShortNameArgument }).ToArray());
-        }
-
-        public override Option<bool> ColumnsAllOption => ParentCommand.ColumnsAllOption;
-
-        public override Option<string[]> ColumnsOption => ParentCommand.ColumnsOption;
-
-        protected override Option GetFilterOption(FilterOptionDefinition def)
-        {
-            return ParentCommand.LegacyFilters[def];
-        }
-
         protected override Task<NewCommandStatus> ExecuteAsync(SearchCommandArgs args, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, ParseResult parseResult, CancellationToken cancellationToken)
         {
             PrintDeprecationMessage<LegacySearchCommand, SearchCommand>(args.ParseResult);
             return base.ExecuteAsync(args, environmentSettings, templatePackageManager, parseResult, cancellationToken);
         }
-
-        private void ValidateParentCommandArguments(CommandResult commandResult)
-        {
-            var nameArgumentResult = commandResult.Children.FirstOrDefault(
-                symbol => symbol is ArgumentResult argumentResult && argumentResult.Argument == NameArgument);
-            if (nameArgumentResult == null)
-            {
-                return;
-            }
-            ParentCommand.ValidateShortNameArgumentIsNotUsed(commandResult);
-        }
     }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommand.cs
index fc3bbf2381d1..d1bc470c4610 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommand.cs
@@ -7,16 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class SearchCommand : BaseSearchCommand
+    internal sealed class SearchCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseSearchCommand(hostBuilder, CommandDefinition.Search.Command)
     {
-        public SearchCommand(
-                NewCommand parentCommand,
-                Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(parentCommand, hostBuilder, "search")
-        {
-            parentCommand.AddNoLegacyUsageValidators(this);
-        }
-
         protected override async Task<NewCommandStatus> ExecuteAsync(
             SearchCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommandArgs.cs
index 6efedc6975b3..e26ff4d46e15 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/search/SearchCommandArgs.cs
@@ -5,11 +5,11 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class SearchCommandArgs : BaseFilterableArgs, ITabularOutputArgs
+    internal sealed class SearchCommandArgs : BaseFilterableArgs, ITabularOutputArgs
     {
         internal SearchCommandArgs(BaseSearchCommand command, ParseResult parseResult) : base(command, parseResult)
         {
-            string? nameCriteria = parseResult.GetValue(BaseSearchCommand.NameArgument);
+            string? nameCriteria = parseResult.GetValue(CommandDefinition.Search.NameArgument);
             if (!string.IsNullOrWhiteSpace(nameCriteria))
             {
                 SearchNameCriteria = nameCriteria;
@@ -17,7 +17,7 @@ internal SearchCommandArgs(BaseSearchCommand command, ParseResult parseResult) :
             // for legacy case new command argument is also accepted
             else if (command is LegacySearchCommand legacySearchCommand)
             {
-                string? newCommandArgument = parseResult.GetValue(NewCommand.ShortNameArgument);
+                string? newCommandArgument = parseResult.GetValue(CommandDefinition.New.ShortNameArgument);
                 if (!string.IsNullOrWhiteSpace(newCommandArgument))
                 {
                     SearchNameCriteria = newCommandArgument;
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs
index aaeff1a38c6a..1b5715163c5d 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/BaseUninstallCommand.cs
@@ -7,22 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class BaseUninstallCommand : BaseCommand<UninstallCommandArgs>
+    internal abstract class BaseUninstallCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder, CommandDefinition definition)
+        : BaseCommand<UninstallCommandArgs>(hostBuilder, definition)
     {
-        internal BaseUninstallCommand(
-            Func<ParseResult, ITemplateEngineHost> hostBuilder,
-            string commandName)
-            : base(hostBuilder, commandName, SymbolStrings.Command_Uninstall_Description)
-        {
-            Arguments.Add(NameArgument);
-        }
-
-        internal static Argument<string[]> NameArgument { get; } = new("package")
-        {
-            Description = SymbolStrings.Command_Uninstall_Argument_Package,
-            Arity = new ArgumentArity(0, 99)
-        };
-
         protected override Task<NewCommandStatus> ExecuteAsync(
             UninstallCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/LegacyUninstallCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/LegacyUninstallCommand.cs
index 4da1b9089b59..c7bc42dad765 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/LegacyUninstallCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/LegacyUninstallCommand.cs
@@ -7,19 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class LegacyUninstallCommand : BaseUninstallCommand
+    internal sealed class LegacyUninstallCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseUninstallCommand(hostBuilder, CommandDefinition.Uninstall.LegacyCommand)
     {
-        public LegacyUninstallCommand(
-            NewCommand parentCommand,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, "--uninstall")
-        {
-            Hidden = true;
-            Aliases.Add("-u");
-
-            parentCommand.AddNoLegacyUsageValidators(this);
-        }
-
         protected override Task<NewCommandStatus> ExecuteAsync(UninstallCommandArgs args, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, ParseResult parseResult, CancellationToken cancellationToken)
         {
             PrintDeprecationMessage<LegacyUninstallCommand, UninstallCommand>(args.ParseResult);
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommand.cs
index a11c17a52702..9f1b56c0cc20 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommand.cs
@@ -7,16 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class UninstallCommand : BaseUninstallCommand
+    internal sealed class UninstallCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseUninstallCommand(hostBuilder, CommandDefinition.Uninstall.Command)
     {
-        public UninstallCommand(
-            NewCommand parentCommand,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(hostBuilder, "uninstall")
-        {
-            parentCommand.AddNoLegacyUsageValidators(this);
-        }
-
         protected override async Task<NewCommandStatus> ExecuteAsync(
             UninstallCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommandArgs.cs
index ff8b59a68e9b..34324d2e27b1 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/uninstall/UninstallCommandArgs.cs
@@ -9,7 +9,7 @@ internal class UninstallCommandArgs : GlobalArgs
     {
         public UninstallCommandArgs(BaseUninstallCommand uninstallCommand, ParseResult parseResult) : base(uninstallCommand, parseResult)
         {
-            TemplatePackages = parseResult.GetValue(BaseUninstallCommand.NameArgument) ?? Array.Empty<string>();
+            TemplatePackages = parseResult.GetValue(CommandDefinition.Uninstall.NameArgument) ?? Array.Empty<string>();
 
             //workaround for --install source1 --install source2 case
             if (uninstallCommand is LegacyUninstallCommand && (TemplatePackages.Contains(uninstallCommand.Name) || uninstallCommand.Aliases.Any(alias => TemplatePackages.Contains(alias))))
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs
index 41d6a14d1145..bedf8d318057 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/BaseUpdateCommand.cs
@@ -7,25 +7,10 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class BaseUpdateCommand : BaseCommand<UpdateCommandArgs>
+    internal abstract class BaseUpdateCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder, CommandDefinition.Update definition)
+        : BaseCommand<UpdateCommandArgs>(hostBuilder, definition)
     {
-        internal BaseUpdateCommand(
-            NewCommand parentCommand,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder,
-            string commandName,
-            string description)
-            : base(hostBuilder, commandName, description)
-        {
-            ParentCommand = parentCommand;
-            Options.Add(InteractiveOption);
-            Options.Add(AddSourceOption);
-        }
-
-        internal virtual Option<bool> InteractiveOption { get; } = SharedOptionsFactory.CreateInteractiveOption();
-
-        internal virtual Option<string[]> AddSourceOption { get; } = SharedOptionsFactory.CreateAddSourceOption();
-
-        protected NewCommand ParentCommand { get; }
+        public CommandDefinition.Update Definition => definition;
 
         protected override Task<NewCommandStatus> ExecuteAsync(
             UpdateCommandArgs args,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs
index 01042ccbb006..487c7f934327 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateApplyCommand.cs
@@ -7,21 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class LegacyUpdateApplyCommand : BaseUpdateCommand
+    internal sealed class LegacyUpdateApplyCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseUpdateCommand(hostBuilder, CommandDefinition.Update.LegacyApplyCommand)
     {
-        public LegacyUpdateApplyCommand(
-            NewCommand parentCommand,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(parentCommand, hostBuilder, "--update-apply", SymbolStrings.Command_Legacy_Update_Check_Description)
-        {
-            Hidden = true;
-            parentCommand.AddNoLegacyUsageValidators(this, except: new Option[] { InteractiveOption, AddSourceOption });
-        }
-
-        internal override Option<bool> InteractiveOption => ParentCommand.InteractiveOption;
-
-        internal override Option<string[]> AddSourceOption => ParentCommand.AddSourceOption;
-
         protected override Task<NewCommandStatus> ExecuteAsync(UpdateCommandArgs args, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, ParseResult parseResult, CancellationToken cancellationToken)
         {
             PrintDeprecationMessage<LegacyUpdateApplyCommand, UpdateCommand>(args.ParseResult);
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs
index da0b0caa460a..4bb5b1cfdab5 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/LegacyUpdateCheckCommand.cs
@@ -7,24 +7,12 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class LegacyUpdateCheckCommand : BaseUpdateCommand
+    internal sealed class LegacyUpdateCheckCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseUpdateCommand(hostBuilder, CommandDefinition.Update.LegacyCheckCommand)
     {
-        public LegacyUpdateCheckCommand(
-            NewCommand parentCommand,
-            Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(parentCommand, hostBuilder, "--update-check", SymbolStrings.Command_Update_Description)
-        {
-            Hidden = true;
-            parentCommand.AddNoLegacyUsageValidators(this, except: new Option[] { InteractiveOption, AddSourceOption });
-        }
-
-        internal override Option<bool> InteractiveOption => ParentCommand.InteractiveOption;
-
-        internal override Option<string[]> AddSourceOption => ParentCommand.AddSourceOption;
-
         protected override Task<NewCommandStatus> ExecuteAsync(UpdateCommandArgs args, IEngineEnvironmentSettings environmentSettings, TemplatePackageManager templatePackageManager, ParseResult parseResult, CancellationToken cancellationToken)
         {
-            PrintDeprecationMessage<LegacyUpdateCheckCommand, UpdateCommand>(args.ParseResult, additionalOption: UpdateCommand.CheckOnlyOption);
+            PrintDeprecationMessage<LegacyUpdateCheckCommand, UpdateCommand>(args.ParseResult, additionalOption: CommandDefinition.Update.CheckOnlyOption);
 
             return base.ExecuteAsync(args, environmentSettings, templatePackageManager, parseResult, cancellationToken);
         }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs
index 37612b07b29c..b838580fa4fa 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommand.cs
@@ -7,23 +7,9 @@
 
 namespace Microsoft.TemplateEngine.Cli.Commands
 {
-    internal class UpdateCommand : BaseUpdateCommand
+    internal sealed class UpdateCommand(Func<ParseResult, ITemplateEngineHost> hostBuilder)
+        : BaseUpdateCommand(hostBuilder, CommandDefinition.Update.Command)
     {
-        public UpdateCommand(
-                NewCommand parentCommand,
-                Func<ParseResult, ITemplateEngineHost> hostBuilder)
-            : base(parentCommand, hostBuilder, "update", SymbolStrings.Command_Update_Description)
-        {
-            parentCommand.AddNoLegacyUsageValidators(this);
-            Options.Add(CheckOnlyOption);
-        }
-
-        internal static Option<bool> CheckOnlyOption { get; } = new("--check-only", "--dry-run")
-        {
-            Description = SymbolStrings.Command_Update_Option_CheckOnly,
-            Arity = ArgumentArity.Zero
-        };
-
         protected override async Task<NewCommandStatus> ExecuteAsync(
             UpdateCommandArgs args,
             IEngineEnvironmentSettings environmentSettings,
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommandArgs.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommandArgs.cs
index 668861087044..1b51ab373b9c 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommandArgs.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/update/UpdateCommandArgs.cs
@@ -9,9 +9,9 @@ internal class UpdateCommandArgs : GlobalArgs
     {
         public UpdateCommandArgs(BaseUpdateCommand command, ParseResult parseResult) : base(command, parseResult)
         {
-            if (command is UpdateCommand updateCommand)
+            if (command is UpdateCommand)
             {
-                CheckOnly = parseResult.GetValue(UpdateCommand.CheckOnlyOption);
+                CheckOnly = parseResult.GetValue(CommandDefinition.Update.CheckOnlyOption);
             }
             else if (command is LegacyUpdateCheckCommand)
             {
@@ -26,8 +26,8 @@ public UpdateCommandArgs(BaseUpdateCommand command, ParseResult parseResult) : b
                 throw new ArgumentException($"Unsupported type {command.GetType().FullName}", nameof(command));
             }
 
-            Interactive = parseResult.GetValue(command.InteractiveOption);
-            AdditionalSources = parseResult.GetValue(command.AddSourceOption);
+            Interactive = parseResult.GetValue(command.Definition.InteractiveOption);
+            AdditionalSources = parseResult.GetValue(command.Definition.AddSourceOption);
         }
 
         public bool CheckOnly { get; }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Microsoft.TemplateEngine.Cli.csproj b/src/Cli/Microsoft.TemplateEngine.Cli/Microsoft.TemplateEngine.Cli.csproj
index e9140b0e10fc..6504a731f36f 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Microsoft.TemplateEngine.Cli.csproj
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Microsoft.TemplateEngine.Cli.csproj
@@ -4,7 +4,6 @@
     <Description>Template creation for the dotnet CLI</Description>
     <IsPackable>true</IsPackable>
     <IsShippingPackage>false</IsShippingPackage>
-    <EnableStyleCopAnalyzer>true</EnableStyleCopAnalyzer>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
     <ImplicitUsings>enable</ImplicitUsings>
     <DefineConstants>$(DefineConstants);WCWIDTH_VISIBILITY_INTERNAL</DefineConstants>
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs b/src/Cli/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs
index eae0deeb2141..841c9e09ea7e 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/NewCommandFactory.cs
@@ -8,16 +8,7 @@ namespace Microsoft.TemplateEngine.Cli
 {
     public static class NewCommandFactory
     {
-        public static Command Create(string commandName, Func<ParseResult, ICliTemplateEngineHost> hostBuilder)
-        {
-            if (string.IsNullOrWhiteSpace(commandName))
-            {
-                throw new ArgumentException($"'{nameof(commandName)}' cannot be null or whitespace.", nameof(commandName));
-            }
-
-            _ = hostBuilder ?? throw new ArgumentNullException(nameof(hostBuilder));
-
-            return new NewCommand(commandName, hostBuilder);
-        }
+        public static Command Create(Func<ParseResult, ICliTemplateEngineHost> hostBuilder)
+            => new NewCommand(hostBuilder ?? throw new ArgumentNullException(nameof(hostBuilder)));
     }
 }
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateInvoker.cs b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateInvoker.cs
index 581ba2892234..a34f201e095c 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateInvoker.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateInvoker.cs
@@ -235,7 +235,7 @@ private async Task<NewCommandStatus> CreateTemplateAsync(TemplateCommandArgs tem
                     Reporter.Error.WriteLine(LocalizableStrings.TemplateCreator_Error_TemplateNotFound.Bold().Red());
                     Reporter.Error.WriteLine();
                     Reporter.Output.WriteLine(LocalizableStrings.TemplateCreator_Hint_RebuildCache);
-                    Reporter.Output.WriteCommand(Example.For<NewCommand>(templateArgs.ParseResult).WithOption(NewCommand.DebugRebuildCacheOption));
+                    Reporter.Output.WriteCommand(Example.For<NewCommand>(templateArgs.ParseResult).WithOption(CommandDefinition.New.DebugRebuildCacheOption));
                     Reporter.Output.WriteLine();
                     IManagedTemplatePackage? templatePackage = null;
                     try
@@ -251,10 +251,10 @@ private async Task<NewCommandStatus> CreateTemplateAsync(TemplateCommandArgs tem
                     if (templatePackage != null)
                     {
                         Reporter.Output.WriteLine(LocalizableStrings.TemplateCreator_Hint_Uninstall);
-                        Reporter.Output.WriteCommand(Example.For<UninstallCommand>(templateArgs.ParseResult).WithArgument(BaseUninstallCommand.NameArgument, templatePackage.DisplayName));
+                        Reporter.Output.WriteCommand(Example.For<UninstallCommand>(templateArgs.ParseResult).WithArgument(CommandDefinition.Uninstall.NameArgument, templatePackage.DisplayName));
                         Reporter.Output.WriteLine();
                         Reporter.Output.WriteLine(LocalizableStrings.TemplateCreator_Hint_Install);
-                        Reporter.Output.WriteCommand(Example.For<InstallCommand>(templateArgs.ParseResult).WithArgument(BaseInstallCommand.NameArgument, templatePackage.DisplayName));
+                        Reporter.Output.WriteCommand(Example.For<InstallCommand>(templateArgs.ParseResult).WithArgument(CommandDefinition.Install.NameArgument, templatePackage.DisplayName));
                         Reporter.Output.WriteLine();
                     }
                     return NewCommandStatus.NotFound;
@@ -266,7 +266,7 @@ private async Task<NewCommandStatus> CreateTemplateAsync(TemplateCommandArgs tem
                     Reporter.Error.WriteCommand(
                         Example
                             .For<NewCommand>(templateArgs.ParseResult)
-                            .WithArgument(NewCommand.ShortNameArgument, templateArgs.Template.ShortNameList[0])
+                            .WithArgument(CommandDefinition.New.ShortNameArgument, templateArgs.Template.ShortNameList[0])
                             .WithHelpOption());
                     return NewCommandStatus.InvalidOption;
                 case CreationResultStatus.DestructiveChangesDetected:
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs
index 4f725fb268ff..a93a620178f8 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateListCoordinator.cs
@@ -78,7 +78,7 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(
                        Example
                            .For<NewCommand>(args.ParseResult)
                            .WithSubcommand<SearchCommand>()
-                           .WithArgument(BaseSearchCommand.NameArgument));
+                           .WithArgument(CommandDefinition.Search.NameArgument));
                     Reporter.Output.WriteLine();
                     return NewCommandStatus.Success;
                 }
@@ -110,7 +110,7 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(
                         string.Format(
                             LocalizableStrings.TemplateListCoordinator_Error_FailedConstraints,
                             resolutionResult.ContraintsMismatchGroupCount,
-                            BaseListCommand.IgnoreConstraintsOption.Name)
+                            CommandDefinition.List.IgnoreConstraintsOption.Name)
                         .Bold().Red());
                 }
 
@@ -123,7 +123,7 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(
                              Example
                                  .For<NewCommand>(args.ParseResult)
                                  .WithSubcommand<SearchCommand>()
-                                 .WithArgument(BaseSearchCommand.NameArgument));
+                                 .WithArgument(CommandDefinition.Search.NameArgument));
                 }
                 else
                 {
@@ -131,7 +131,7 @@ internal async Task<NewCommandStatus> DisplayTemplateGroupListAsync(
                              Example
                                  .For<NewCommand>(args.ParseResult)
                                  .WithSubcommand<SearchCommand>()
-                                 .WithArgument(BaseSearchCommand.NameArgument, args.ListNameCriteria));
+                                 .WithArgument(CommandDefinition.Search.NameArgument, args.ListNameCriteria));
                 }
                 Reporter.Error.WriteLine();
                 return NewCommandStatus.NotFound;
@@ -165,7 +165,7 @@ internal async Task<NewCommandStatus> DisplayCommandDescriptionAsync(
             Reporter.Output.WriteCommand(
                Example
                    .For<NewCommand>(args.ParseResult)
-                   .WithArgument(NewCommand.ShortNameArgument, "console"));
+                   .WithArgument(CommandDefinition.New.ShortNameArgument, "console"));
 
             Reporter.Output.WriteLine();
 
@@ -173,7 +173,7 @@ internal async Task<NewCommandStatus> DisplayCommandDescriptionAsync(
             Reporter.Output.WriteCommand(
               Example
                   .For<NewCommand>(args.ParseResult)
-                  .WithArgument(NewCommand.ShortNameArgument, "console")
+                  .WithArgument(CommandDefinition.New.ShortNameArgument, "console")
                   .WithHelpOption());
 
             Reporter.Output.WriteLine(LocalizableStrings.TemplateInformationCoordinator_DotnetNew_ListTemplatesHint);
@@ -188,7 +188,7 @@ internal async Task<NewCommandStatus> DisplayCommandDescriptionAsync(
                      Example
                          .For<NewCommand>(args.ParseResult)
                          .WithSubcommand<SearchCommand>()
-                         .WithArgument(BaseSearchCommand.NameArgument, "web"));
+                         .WithArgument(CommandDefinition.Search.NameArgument, "web"));
 
             Reporter.Output.WriteLine();
 
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/TemplatePackageCoordinator.cs b/src/Cli/Microsoft.TemplateEngine.Cli/TemplatePackageCoordinator.cs
index 22da91898061..b707887e9f27 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/TemplatePackageCoordinator.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/TemplatePackageCoordinator.cs
@@ -153,7 +153,7 @@ internal void DisplayUpdateCheckResult(CheckUpdateResult versionCheckResult, ICo
                         Example
                             .For<NewCommand>(args.ParseResult)
                             .WithSubcommand<InstallCommand>()
-                            .WithArgument(BaseInstallCommand.NameArgument, $"{versionCheckResult.TemplatePackage?.Identifier}@{versionCheckResult.LatestVersion}"));
+                            .WithArgument(CommandDefinition.Install.NameArgument, $"{versionCheckResult.TemplatePackage?.Identifier}@{versionCheckResult.LatestVersion}"));
                     Reporter.Output.WriteLine();
                 }
             }
@@ -172,7 +172,7 @@ internal void DisplayBuiltInPackagesCheckResult(string packageId, string version
                 Example
                  .For<NewCommand>(args.ParseResult)
                  .WithSubcommand<UninstallCommand>()
-                 .WithArgument(BaseUninstallCommand.NameArgument, packageId));
+                 .WithArgument(CommandDefinition.Uninstall.NameArgument, packageId));
         }
 
         /// <summary>
@@ -643,7 +643,7 @@ private async Task<bool> ValidateInstallationRequestsAsync(InstallCommandArgs ar
                     reporter.WriteCommand(
                         Example
                             .For<InstallCommand>(args.ParseResult)
-                            .WithArgument(BaseInstallCommand.NameArgument, installRequests.Select(ir => ir.DisplayName).ToArray())
+                            .WithArgument(CommandDefinition.Install.NameArgument, installRequests.Select(ir => ir.DisplayName).ToArray())
                             .WithOption(SharedOptions.ForceOption));
                     return false;
                 }
@@ -744,7 +744,7 @@ private async Task<bool> ValidateInstallationRequestsAsync(InstallCommandArgs ar
                                  Example
                                     .For<NewCommand>(commandArgs.ParseResult)
                                     .WithSubcommand<UninstallCommand>()
-                                    .WithArgument(BaseUninstallCommand.NameArgument));
+                                    .WithArgument(CommandDefinition.Uninstall.NameArgument));
                         }
                         else
                         {
@@ -752,7 +752,7 @@ private async Task<bool> ValidateInstallationRequestsAsync(InstallCommandArgs ar
                                  Example
                                     .For<NewCommand>(commandArgs.ParseResult)
                                     .WithSubcommand<UninstallCommand>()
-                                    .WithArgument(BaseUninstallCommand.NameArgument, managedPackages.First().Identifier));
+                                    .WithArgument(CommandDefinition.Uninstall.NameArgument, managedPackages.First().Identifier));
                         }
                     }
                     else
@@ -844,12 +844,12 @@ private void DisplayUpdateCheckResults(IEnumerable<CheckUpdateResult> versionChe
                     Example
                         .For<NewCommand>(args.ParseResult)
                         .WithSubcommand<InstallCommand>()
-                        .WithArgument(BaseInstallCommand.NameArgument, $"<package>@<version>"));
+                        .WithArgument(CommandDefinition.Install.NameArgument, $"<package>@<version>"));
                 Reporter.Output.WriteCommand(
                       Example
                           .For<NewCommand>(args.ParseResult)
                           .WithSubcommand<InstallCommand>()
-                          .WithArgument(BaseInstallCommand.NameArgument, $"{displayableResults.First().Identifier}@{displayableResults.First().LatestVersion}"));
+                          .WithArgument(CommandDefinition.Install.NameArgument, $"{displayableResults.First().Identifier}@{displayableResults.First().LatestVersion}"));
                 Reporter.Output.WriteLine();
                 Reporter.Output.WriteLine(LocalizableStrings.TemplatePackageCoordinator_Update_Info_UpdateAllCommandHeader);
                 Reporter.Output.WriteCommand(
@@ -921,7 +921,7 @@ private async Task DisplayInstalledTemplatePackagesAsync(GlobalArgs args, Cancel
                     Example
                         .For<NewCommand>(args.ParseResult)
                         .WithSubcommand<UninstallCommand>()
-                        .WithArgument(BaseUninstallCommand.NameArgument, managedSource.Identifier),
+                        .WithArgument(CommandDefinition.Uninstall.NameArgument, managedSource.Identifier),
                     indentLevel: 2);
 
                 Reporter.Output.WriteLine();
@@ -1003,8 +1003,8 @@ private async Task DisplayInstallResultAsync(string packageToInstall, InstallerO
                               string.Format(
                                   LocalizableStrings.TemplatePackageCoordinator_lnstall_Error_AlreadyInstalled,
                                   packageToInstall).Bold().Red());
-                        Reporter.Error.WriteLine(LocalizableStrings.TemplatePackageCoordinator_lnstall_Error_AlreadyInstalled_Hint, BaseInstallCommand.ForceOption.Aliases.First());
-                        Reporter.Error.WriteCommand(Example.For<InstallCommand>(parseResult).WithArgument(BaseInstallCommand.NameArgument, packageToInstall).WithOption(BaseInstallCommand.ForceOption));
+                        Reporter.Error.WriteLine(LocalizableStrings.TemplatePackageCoordinator_lnstall_Error_AlreadyInstalled_Hint, CommandDefinition.Install.ForceOption.Aliases.First());
+                        Reporter.Error.WriteCommand(Example.For<InstallCommand>(parseResult).WithArgument(CommandDefinition.Install.NameArgument, packageToInstall).WithOption(CommandDefinition.Install.ForceOption));
 
                         break;
                     case InstallerErrorCode.UpdateUninstallFailed:
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/TemplatePackageDisplay.cs b/src/Cli/Microsoft.TemplateEngine.Cli/TemplatePackageDisplay.cs
index 4af28fdd7f97..5f734beb0fb0 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/TemplatePackageDisplay.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/TemplatePackageDisplay.cs
@@ -55,7 +55,7 @@ internal void DisplayUpdateCheckResult(CheckUpdateResult versionCheckResult, ICo
                         Example
                             .For<NewCommand>(args.ParseResult)
                             .WithSubcommand<InstallCommand>()
-                            .WithArgument(BaseInstallCommand.NameArgument, $"{versionCheckResult.TemplatePackage?.Identifier}@{versionCheckResult.LatestVersion}"));
+                            .WithArgument(CommandDefinition.Install.NameArgument, $"{versionCheckResult.TemplatePackage?.Identifier}@{versionCheckResult.LatestVersion}"));
                     _reporterOutput.WriteLine();
                 }
             }
@@ -74,7 +74,7 @@ internal void DisplayBuiltInPackagesCheckResult(string packageId, string version
                 Example
                  .For<NewCommand>(args.ParseResult)
                  .WithSubcommand<UninstallCommand>()
-                 .WithArgument(BaseUninstallCommand.NameArgument, packageId));
+                 .WithArgument(CommandDefinition.Uninstall.NameArgument, packageId));
         }
 
         internal async Task DisplayInstallResultAsync(
@@ -156,8 +156,8 @@ internal async Task DisplayInstallResultAsync(
                               string.Format(
                                   LocalizableStrings.TemplatePackageCoordinator_lnstall_Error_AlreadyInstalled,
                                   packageToInstall).Bold().Red());
-                        _reporterError.WriteLine(LocalizableStrings.TemplatePackageCoordinator_lnstall_Error_AlreadyInstalled_Hint, BaseInstallCommand.ForceOption.Name);
-                        _reporterError.WriteCommand(Example.For<InstallCommand>(parseResult).WithArgument(BaseInstallCommand.NameArgument, packageToInstall).WithOption(BaseInstallCommand.ForceOption));
+                        _reporterError.WriteLine(LocalizableStrings.TemplatePackageCoordinator_lnstall_Error_AlreadyInstalled_Hint, CommandDefinition.Install.ForceOption.Name);
+                        _reporterError.WriteCommand(Example.For<InstallCommand>(parseResult).WithArgument(CommandDefinition.Install.NameArgument, packageToInstall).WithOption(CommandDefinition.Install.ForceOption));
 
                         break;
                     case InstallerErrorCode.UpdateUninstallFailed:
@@ -186,7 +186,7 @@ internal async Task DisplayInstallResultAsync(
                                        LocalizableStrings.TemplatePackageCoordinator_Install_Error_VulnerablePackageTip,
                                        packageToInstall,
                                        SharedOptions.ForceOption.Name).Bold());
-                                    _reporterError.WriteCommand(Example.For<InstallCommand>(parseResult).WithArgument(BaseInstallCommand.NameArgument, packageToInstall).WithOption(BaseInstallCommand.ForceOption));
+                                    _reporterError.WriteCommand(Example.For<InstallCommand>(parseResult).WithArgument(CommandDefinition.Install.NameArgument, packageToInstall).WithOption(CommandDefinition.Install.ForceOption));
                                     break;
 
                                 case UpdateResult updateRequest when updateRequest.Vulnerabilities.Any():
@@ -198,8 +198,8 @@ internal async Task DisplayInstallResultAsync(
                                         LocalizableStrings.TemplatePackageCoordinator_Update_Error_VulnerablePackageTip,
                                         packageToInstall,
                                         SharedOptions.ForceOption.Name).Bold());
-                                    _reporterError.WriteCommand(Example.For<UninstallCommand>(parseResult).WithArgument(BaseUninstallCommand.NameArgument, packageToInstall));
-                                    _reporterError.WriteCommand(Example.For<InstallCommand>(parseResult).WithArgument(BaseInstallCommand.NameArgument, packageToInstall).WithOption(BaseInstallCommand.ForceOption));
+                                    _reporterError.WriteCommand(Example.For<UninstallCommand>(parseResult).WithArgument(CommandDefinition.Uninstall.NameArgument, packageToInstall));
+                                    _reporterError.WriteCommand(Example.For<InstallCommand>(parseResult).WithArgument(CommandDefinition.Install.NameArgument, packageToInstall).WithOption(CommandDefinition.Install.ForceOption));
                                     break;
 
                                 default:
@@ -267,7 +267,7 @@ internal async Task DisplayInstalledTemplatePackagesAsync(TemplatePackageManager
                     Example
                         .For<NewCommand>(args.ParseResult)
                         .WithSubcommand<UninstallCommand>()
-                        .WithArgument(BaseUninstallCommand.NameArgument, managedSource.Identifier),
+                        .WithArgument(CommandDefinition.Uninstall.NameArgument, managedSource.Identifier),
                     indentLevel: 2);
 
                 Reporter.Output.WriteLine();
@@ -303,12 +303,12 @@ internal void DisplayUpdateCheckResults(IEngineEnvironmentSettings engineEnviron
                     Example
                         .For<NewCommand>(args.ParseResult)
                         .WithSubcommand<InstallCommand>()
-                        .WithArgument(BaseInstallCommand.NameArgument, $"<package>@<version>"));
+                        .WithArgument(CommandDefinition.Install.NameArgument, $"<package>@<version>"));
                 Reporter.Output.WriteCommand(
                       Example
                           .For<NewCommand>(args.ParseResult)
                           .WithSubcommand<InstallCommand>()
-                          .WithArgument(BaseInstallCommand.NameArgument, $"{displayableResults.First().Identifier}@{displayableResults.First().LatestVersion}"));
+                          .WithArgument(CommandDefinition.Install.NameArgument, $"{displayableResults.First().Identifier}@{displayableResults.First().LatestVersion}"));
                 Reporter.Output.WriteLine();
                 Reporter.Output.WriteLine(LocalizableStrings.TemplatePackageCoordinator_Update_Info_UpdateAllCommandHeader);
                 Reporter.Output.WriteCommand(
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateResolution/TemplateMatchInfoExtensions.cs b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateResolution/TemplateMatchInfoExtensions.cs
index 118435620048..4a70d44f68d0 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateResolution/TemplateMatchInfoExtensions.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateResolution/TemplateMatchInfoExtensions.cs
@@ -43,7 +43,7 @@ internal static bool HasMismatchOnConstraints(this ITemplateMatchInfo templateMa
 
         internal static bool HasMismatchOnListFilters(this ITemplateMatchInfo templateMatchInfo)
         {
-            IEnumerable<string> supportedFilters = BaseListCommand.SupportedFilters.OfType<TemplateFilterOptionDefinition>().Select(f => f.MatchInfoName);
+            IEnumerable<string> supportedFilters = CommandDefinition.List.SupportedFilters.OfType<TemplateFilterOptionDefinition>().Select(f => f.MatchInfoName);
 
             var filterMatches = templateMatchInfo.MatchDisposition.Where(mi => supportedFilters.Any(f => f == mi.Name));
             var otherMatches = templateMatchInfo.MatchDisposition.Where(mi => !supportedFilters.Any(f => f == mi.Name));
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateSearch/CliTemplateSearchCoordinator.cs b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateSearch/CliTemplateSearchCoordinator.cs
index 2a7661fcd7b4..ccd36f379d99 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/TemplateSearch/CliTemplateSearchCoordinator.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/TemplateSearch/CliTemplateSearchCoordinator.cs
@@ -95,13 +95,13 @@ internal static async Task<NewCommandStatus> SearchForTemplateMatchesAsync(
                  Example
                      .For<NewCommand>(commandArgs.ParseResult)
                      .WithSubcommand<InstallCommand>()
-                     .WithArgument(BaseInstallCommand.NameArgument));
+                     .WithArgument(CommandDefinition.Install.NameArgument));
                 Reporter.Output.WriteLine(LocalizableStrings.Generic_ExampleHeader);
                 Reporter.Output.WriteCommand(
                    Example
                        .For<NewCommand>(commandArgs.ParseResult)
                        .WithSubcommand<InstallCommand>()
-                       .WithArgument(BaseInstallCommand.NameArgument, packageIdToShow));
+                       .WithArgument(CommandDefinition.Install.NameArgument, packageIdToShow));
                 return NewCommandStatus.Success;
             }
             return NewCommandStatus.NotFound;
@@ -253,13 +253,13 @@ private static bool ValidateCommandInput(SearchCommandArgs commandArgs)
             // && !commandInput.RemainingParameters.Any())
             {
                 Reporter.Error.WriteLine(LocalizableStrings.CliTemplateSearchCoordinator_Error_NoTemplateName.Red().Bold());
-                Reporter.Error.WriteLine(LocalizableStrings.CliTemplateSearchCoordinator_Info_SearchHelp, string.Join(", ", BaseSearchCommand.SupportedFilters.Select(f => $"'{f.OptionFactory().Name}'")));
+                Reporter.Error.WriteLine(LocalizableStrings.CliTemplateSearchCoordinator_Info_SearchHelp, string.Join(", ", CommandDefinition.Search.SupportedFilters.Select(f => $"'{f.OptionFactory().Name}'")));
                 Reporter.Error.WriteLine(LocalizableStrings.Generic_ExamplesHeader);
                 Reporter.Error.WriteCommand(
                     Example
                         .For<NewCommand>(commandArgs.ParseResult)
                         .WithSubcommand<SearchCommand>()
-                        .WithArgument(BaseSearchCommand.NameArgument, "web"));
+                        .WithArgument(CommandDefinition.Search.NameArgument, "web"));
 
                 Reporter.Error.WriteCommand(
                      Example
@@ -271,7 +271,7 @@ private static bool ValidateCommandInput(SearchCommandArgs commandArgs)
                  Example
                     .For<NewCommand>(commandArgs.ParseResult)
                     .WithSubcommand<SearchCommand>()
-                    .WithArgument(BaseSearchCommand.NameArgument, "web")
+                    .WithArgument(CommandDefinition.Search.NameArgument, "web")
                     .WithOption(SharedOptionsFactory.CreateLanguageOption(), "C#"));
 
                 return false;
diff --git a/src/Cli/dotnet/Commands/New/NewCommandParser.cs b/src/Cli/dotnet/Commands/New/NewCommandParser.cs
index 45337f19ea72..6100aeeda695 100644
--- a/src/Cli/dotnet/Commands/New/NewCommandParser.cs
+++ b/src/Cli/dotnet/Commands/New/NewCommandParser.cs
@@ -65,7 +65,7 @@ internal static class NewCommandParser
 
     public static Command GetCommand()
     {
-        Command command = NewCommandFactory.Create(CommandName, (Func<ParseResult, CliTemplateEngineHost>)GetEngineHost);
+        Command command = NewCommandFactory.Create((Func<ParseResult, CliTemplateEngineHost>)GetEngineHost);
         command.Options.Add(s_disableSdkTemplatesOption);
         command.Options.Add(s_disableProjectContextEvaluationOption);
         command.Options.Add(s_verbosityOption);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/AliasAssignmentTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/AliasAssignmentTests.cs
index 049de8305875..0ccf70119531 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/AliasAssignmentTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/AliasAssignmentTests.cs
@@ -259,7 +259,7 @@ public void CanAssignAliasForParameterWithReservedAlias(string parameterName, st
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager templatePackageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new {command}");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             TemplateGroup templateGroup = TemplateGroup
@@ -290,7 +290,7 @@ public void CanOverrideAliasesForParameterWithHostData(string hostJsonData, stri
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager templatePackageManager = A.Fake<TemplatePackageManager>();
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse(" new foo");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, templatePackageManager, templateGroup);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.Resolution.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.Resolution.cs
index e4a6f754e339..955b01f6f266 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.Resolution.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.Resolution.cs
@@ -25,7 +25,7 @@ public void UniqueNameMatchesCorrectly()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new console2");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -50,7 +50,7 @@ public Task FailedToResolveTemplate_WhenMultipleLanguagesAreFound()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new console");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -80,7 +80,7 @@ public void DefaultLanguageDisambiguates()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new console");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -110,7 +110,7 @@ public void InputLanguageIsPreferredOverDefault()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console --language L2");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -136,7 +136,7 @@ public void TemplatesAreSameLanguage()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -163,7 +163,7 @@ public void HasLanguageMismatch()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console --language L2");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -186,7 +186,7 @@ public void HasTypeMismatch()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console --type item");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -209,7 +209,7 @@ public void HasBaselineMismatch()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console --baseline core");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -232,7 +232,7 @@ public void HasMultipleMismatches()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console --language L2 --type item --baseline core");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -260,7 +260,7 @@ public void HasTypeMismatch_HasGroupLanguageMatch()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console --language L2 --type item");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -295,7 +295,7 @@ public void OtherParameterMatch_Text()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console --langVersion ver");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -330,7 +330,7 @@ public void OtherParameterMatch_Choice()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console --framework netcoreapp1.0");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -366,7 +366,7 @@ public void OtherParameterDoesNotExist()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new console --do-not-exist");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             IEnumerable<TemplateCommand> matchingTemplates = InstantiateCommand.GetMatchingTemplates(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.cs
index 67e04cc305fd..0a32d523f3c8 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/HelpTests.cs
@@ -68,7 +68,7 @@ public void CanShowUsage()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             StringWriter sw = new();
             HelpContext helpContext = new(new HelpBuilder(), myCommand, sw);
 
@@ -81,7 +81,7 @@ public void CanShowUsage_ForMultipleShortNames()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             StringWriter sw = new();
             HelpContext helpContext = new(new HelpBuilder(), myCommand, sw);
 
@@ -101,7 +101,7 @@ public Task CanShowCommandOptions_Basic()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -124,7 +124,7 @@ public Task CanShowCommandOptions_Language()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -147,7 +147,7 @@ public Task CanShowCommandOptions_Type()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -170,7 +170,7 @@ public void CanShowCommandOptions_NoOptions()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -194,7 +194,7 @@ public Task CanShowTemplateOptions_SingleTemplate_Choice()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -220,7 +220,7 @@ public Task CanShowTemplateOptions_MultipleTemplate_CombinedChoice()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand1 = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[0]);
             TemplateCommand templateCommand2 = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[1]);
@@ -245,7 +245,7 @@ public Task CanShowTemplateOptions_SingleTemplate_NonChoice()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -273,7 +273,7 @@ public Task CanShowTemplateOptions_MultipleTemplate_MultipleParams()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand1 = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[0]);
             TemplateCommand templateCommand2 = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[1]);
@@ -298,7 +298,7 @@ public Task CanShowTemplateOptions_SingleTemplate_Choice_Required()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -322,7 +322,7 @@ public void CanShowTemplateOptions_RequiredIsNotShownWhenDefaultValueIsGiven()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -345,7 +345,7 @@ public Task CanShowHintsForOtherTemplates()
 
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse("new -h");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
@@ -368,7 +368,7 @@ public Task CanShowTemplateOptions_SingleTemplate_Choice_ShortenedUsage_FirstTwo
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -392,7 +392,7 @@ public Task CanShowTemplateOptions_SingleTemplate_Choice_ShortenedUsage()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
@@ -434,7 +434,7 @@ public Task DoesNotCombineParametersWhenAliasesAreDifferent()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand1 = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[0]);
             TemplateCommand templateCommand2 = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates[1]);
@@ -459,7 +459,7 @@ public Task CanShowTemplateOptions_RequiredParam()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
 
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
index 5716bc4f1b85..75b8cfc0402c 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstallTests.cs
@@ -15,7 +15,7 @@ public class InstallTests : BaseTest
         public void Install_CanParseAddSourceOption(string optionName)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new install source {optionName} my-custom-source");
             InstallCommandArgs args = new((InstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -31,7 +31,7 @@ public void Install_CanParseAddSourceOption(string optionName)
         public void Install_Error_NoArguments()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new install");
 
@@ -45,7 +45,7 @@ public void Install_Error_NoArguments()
         public void Install_Legacy_Error_NoArguments()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new --install --interactive");
 
@@ -61,7 +61,7 @@ public void Install_Legacy_Error_NoArguments()
         public void Install_CanParseAddSourceOption_MultipleEntries(string testCase)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new((InstallCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -77,7 +77,7 @@ public void Install_CanParseAddSourceOption_MultipleEntries(string testCase)
         public void Install_CanParseInteractiveOption()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new install source --interactive");
             InstallCommandArgs args = new((InstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -98,7 +98,7 @@ public void Install_CanParseInteractiveOption()
         public void Install_CanParseForceOption()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new install source --force");
             InstallCommandArgs args = new((InstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -119,7 +119,7 @@ public void Install_CanParseForceOption()
         public void Install_CanParseMultipleArgs()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new install source1 source2");
             InstallCommandArgs args = new((InstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -136,7 +136,7 @@ public void Install_CanParseMultipleArgs()
         public void Install_Legacy_CanParseAddSourceOption(string testCase)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -154,7 +154,7 @@ public void Install_Legacy_CanParseAddSourceOption(string testCase)
         public void Install_Legacy_CanParseInteractiveOption(string testCase)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -170,7 +170,7 @@ public void Install_Legacy_CanParseInteractiveOption(string testCase)
         public void Install_Legacy_CanParseMultipleArgs(string testCase)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -187,7 +187,7 @@ public void Install_Legacy_CanParseMultipleArgs(string testCase)
         public void Install_Legacy_CanParseAddSourceOption_MultipleEntries(string testCase)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse(testCase);
             InstallCommandArgs args = new((LegacyInstallCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -209,7 +209,7 @@ public void Install_Legacy_CanParseAddSourceOption_MultipleEntries(string testCa
         public void Install_CanReturnParseError(string command, string expectedInvalidTokens)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             IEnumerable<string> errorMessages = parseResult.Errors.Select(error => error.Message);
@@ -228,14 +228,14 @@ public void Install_CanReturnParseError(string command, string expectedInvalidTo
         public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             Command rootCommand = new("dotnet")
             {
                 myCommand
             };
 
             ParseResult parseResult = rootCommand.Parse("dotnet new install source");
-            Assert.Equal("dotnet new install my-source", Example.For<NewCommand>(parseResult).WithSubcommand<InstallCommand>().WithArgument(BaseInstallCommand.NameArgument, "my-source"));
+            Assert.Equal("dotnet new install my-source", Example.For<NewCommand>(parseResult).WithSubcommand<InstallCommand>().WithArgument(CommandDefinition.Install.NameArgument, "my-source"));
         }
 
     }
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.NoMatchHandling.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.NoMatchHandling.cs
index 9ac29653c07b..838ff0e06517 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.NoMatchHandling.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.NoMatchHandling.cs
@@ -298,7 +298,7 @@ internal void CanEvaluateInvalidParameters(string command, MockTemplateInfo[] te
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager templatePackageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new {command}");
             var args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             HashSet<TemplateCommand> templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs
index a830cf96d278..65fd81f1465f 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.Subcommand.cs
@@ -18,7 +18,7 @@ public partial class InstantiateTests
         public void Create_CanParseTemplateWithOptions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse("new create console --framework net5.0");
             InstantiateCommandArgs args = new((InstantiateCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -47,7 +47,7 @@ internal void Create_CanEvaluateTemplateToRun(string command, string templateSet
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -75,7 +75,7 @@ internal void Create_CanParseNameOption(string command, string? expectedValue)
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
             RootCommand rootCommand = new();
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             rootCommand.Add(myCommand);
 
             ParseResult parseResult = rootCommand.Parse(command);
@@ -112,7 +112,7 @@ internal void Create_CanValidateOptionUsage_InNewCommand(string command, string?
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
             RootCommand rootCommand = new();
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             rootCommand.Add(myCommand);
 
             ParseResult parseResult = rootCommand.Parse(command);
@@ -141,7 +141,7 @@ internal void Create_CanParseTemplateOptions(string command, string parameterNam
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -176,7 +176,7 @@ internal void Create_CanParseChoiceTemplateOptions(string command, string parame
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -218,7 +218,7 @@ internal void Create_CanDetectParseErrorsTemplateOptions(
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -252,7 +252,7 @@ internal void Create_CanDetectParseErrorsChoiceTemplateOptions(
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
@@ -279,7 +279,7 @@ internal void Create_CanEvaluateTemplateWithSubcommandShortName(string command,
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost();
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new create {command}");
             var instantiateCommand = (InstantiateCommand)parseResult.CommandResult.Command;
             var args = new InstantiateCommandArgs(instantiateCommand, parseResult);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs
index be602117b2fe..2e853e190368 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/InstantiateTests.cs
@@ -19,7 +19,7 @@ public partial class InstantiateTests : BaseTest
         public void Instantiate_CanParseTemplateWithOptions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse("new console --framework net5.0");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
@@ -223,7 +223,7 @@ internal void CanEvaluateTemplateToRun(string command, string templateSet, strin
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new {command}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             HashSet<TemplateCommand> templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -250,7 +250,7 @@ internal void CanParseNameOption(string command, string? expectedValue)
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
             RootCommand rootCommand = new();
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             rootCommand.Subcommands.Add(myCommand);
             ParseResult parseResult = rootCommand.Parse(command);
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
@@ -316,7 +316,7 @@ internal void CanParseTemplateOptions(string command, string parameterName, stri
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             Command parser = ParserFactory.CreateParser(myCommand);
             ParseResult parseResult = parser.Parse($" new {command}", ParserFactory.ParserConfiguration);
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
@@ -360,7 +360,7 @@ internal void CanParseChoiceTemplateOptions(string command, string parameterName
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new {command}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -404,7 +404,7 @@ internal void CanParseMultiChoiceTemplateOptions(string command, string paramete
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new {command}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             TemplateCommand templateCommand = new(myCommand, settings, packageManager, templateGroup, templateGroup.Templates.Single());
@@ -474,7 +474,7 @@ internal void CanDetectParseErrorsTemplateOptions(
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new {command}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
@@ -518,7 +518,7 @@ internal void CanDetectParseErrorsChoiceTemplateOptions(
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             Command parser = ParserFactory.CreateParser(myCommand);
             ParseResult parseResult = parser.Parse($" new {command}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
@@ -543,7 +543,7 @@ internal void DoNotAddAllowScriptOptionForTemplate()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
@@ -576,7 +576,7 @@ internal void CanParseAllowScriptsOption(string command, AllowRunScripts? result
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse(command);
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
@@ -609,7 +609,7 @@ public void AllTemplatesInGroupUseAllShortNamesForResolution(string shortName)
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new {shortName}");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             HashSet<TemplateCommand> templateCommands = InstantiateCommand.GetTemplateCommand(args, settings, A.Fake<TemplatePackageManager>(), templateGroup);
@@ -637,7 +637,7 @@ public void ExplicitLanguageChoiceIsHonoredWithMultipleShortNames(string shortNa
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             string command = $"new {shortName} --language F#";
             ParseResult parseResult = myCommand.Parse(command);
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
@@ -667,7 +667,7 @@ public void ChoiceValueDisambiguatesMatchesWithMultipleShortNames(string name, s
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             string command = $"new {name} --foo {fooChoice}";
             ParseResult parseResult = myCommand.Parse($" new {command}");
@@ -697,7 +697,7 @@ public void ParameterExistenceDisambiguatesMatchesWithMultipleShortNames(string
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(defaultParameters: defaultParams);
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             string command = $"new {name} --{paramName} {paramValue}";
             ParseResult parseResult = myCommand.Parse($" new {command}");
@@ -735,7 +735,7 @@ internal void CanParseFlagsOption(string command, string action)
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
             RootCommand rootCommand = new();
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             rootCommand.Subcommands.Add(myCommand);
             ParseResult parseResult = rootCommand.Parse(command);
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
@@ -766,7 +766,7 @@ internal void CanParse_WithoutRequiredParameter()
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
             RootCommand rootCommand = new();
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             rootCommand.Subcommands.Add(myCommand);
             ParseResult parseResult = rootCommand.Parse("new foo");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs
index d8f69adfdca2..469fcc6b4046 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/ListTests.cs
@@ -78,7 +78,7 @@ public void List_CanParseFilterOption(string command, string expectedFilter)
             FilterOptionDefinition expectedDef = _stringToFilterDefMap[expectedFilter];
 
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             ListCommandArgs args = new((BaseListCommand)parseResult.CommandResult.Command, parseResult);
@@ -119,7 +119,7 @@ public void List_CanParseFilterOptionWithoutMainCriteria(string command, string
             FilterOptionDefinition expectedDef = _stringToFilterDefMap[expectedFilter];
 
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             ListCommandArgs args = new((BaseListCommand)parseResult.CommandResult.Command, parseResult);
@@ -135,7 +135,7 @@ public void List_CanParseFilterOptionWithoutMainCriteria(string command, string
         public void List_CannotParseMultipleArgs(string command)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -147,7 +147,7 @@ public void List_CannotParseMultipleArgs(string command)
         public void List_CannotParseArgsAtNewLevel()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new smth list");
 
@@ -164,7 +164,7 @@ public void List_CannotParseArgsAtNewLevel()
         public void List_CannotParseOptionsAtNewLevel(string command, string expectedFilter)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -176,7 +176,7 @@ public void List_CannotParseOptionsAtNewLevel(string command, string expectedFil
         public void List_Legacy_CannotParseArgsAtBothLevels()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new smth --list smth-else");
 
@@ -191,7 +191,7 @@ public void List_Legacy_CannotParseArgsAtBothLevels()
         public void List_CanParseColumnsAll(string command)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -211,7 +211,7 @@ public void List_CanParseColumnsAll(string command)
         public void List_CanParseColumns(string command, string[] expectedColumns)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -233,7 +233,7 @@ public void List_CanParseColumns(string command, string[] expectedColumns)
         public void List_CannotParseUnknownColumns(string command)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -249,7 +249,7 @@ public void List_CannotParseUnknownColumns(string command)
         public void List_HandleParseErrors(string command, string expectedInvalidTokens)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             IEnumerable<string> errorMessages = parseResult.Errors.Select(error => error.Message);
@@ -268,7 +268,7 @@ public void List_HandleParseErrors(string command, string expectedInvalidTokens)
         public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             Command rootCommand = new("dotnet")
             {
                 myCommand
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs
index 6d422bdf94e4..25c870de3dae 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/MiscTests.cs
@@ -75,7 +75,7 @@ public void DebugFlagCanBeParsedOnNewLevel(string command, string option)
             };
 
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = ParserFactory.CreateParser(myCommand).Parse(command);
             NewCommandArgs args = new(myCommand, parseResult);
 
@@ -105,7 +105,7 @@ public void DebugFlagCanBeParsedOnSubcommandLevel(string command, string option)
             };
 
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = ParserFactory.CreateParser(myCommand).Parse(command);
             InstallCommandArgs args = new((InstallCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -135,7 +135,7 @@ public void DebugFlagCanBeParsedOnTemplateSubcommandLevel(string command, string
             };
 
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse(command);
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
@@ -148,7 +148,7 @@ public void DebugFlagCanBeParsedOnTemplateSubcommandLevel(string command, string
         public void ManuallyAddedOptionIsPreservedOnTemplateSubcommandLevel()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             var customOption = new Option<string>("--newOption")
             {
@@ -178,7 +178,7 @@ public void CanParseOutputOption(string command, string? expected)
 
             RootCommand rootCommand = new();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             rootCommand.Add(myCommand);
 
             ParseResult parseResult = rootCommand.Parse(command);
@@ -196,7 +196,7 @@ public void CanParseProjectOption(string command, string? expected)
 
             RootCommand rootCommand = new();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             rootCommand.Add(myCommand);
 
             // ProjectPathOption uses AcceptExistingOnly validator, so the provided file has to exist!
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
index cc75fe669e23..f8be0dfccca5 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/SearchTests.cs
@@ -60,7 +60,7 @@ public void Search_CanParseFilterOption(string command, string expectedFilter)
             FilterOptionDefinition expectedDef = _stringToFilterDefMap[expectedFilter];
 
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             SearchCommandArgs args = new((BaseSearchCommand)parseResult.CommandResult.Command, parseResult);
@@ -94,7 +94,7 @@ public void Search_CanParseFilterOptionWithoutMainCriteria(string command, strin
             FilterOptionDefinition expectedDef = _stringToFilterDefMap[expectedFilter];
 
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             SearchCommandArgs args = new((BaseSearchCommand)parseResult.CommandResult.Command, parseResult);
@@ -110,7 +110,7 @@ public void Search_CanParseFilterOptionWithoutMainCriteria(string command, strin
         public void Search_CannotParseMultipleArgs(string command)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -122,7 +122,7 @@ public void Search_CannotParseMultipleArgs(string command)
         public void Search_CannotParseArgsAtNewLevel()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse("new smth search");
 
             Assert.NotEmpty(parseResult.Errors);
@@ -139,7 +139,7 @@ public void Search_CannotParseArgsAtNewLevel()
         public void Search_CannotParseOptionsAtNewLevel(string command, string expectedFilter)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -151,7 +151,7 @@ public void Search_CannotParseOptionsAtNewLevel(string command, string expectedF
         public void Search_Legacy_CannotParseArgsAtBothLevels()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new smth --search smth-else");
 
@@ -167,7 +167,7 @@ public void Search_Legacy_CannotParseArgsAtBothLevels()
         public void Search_HandleParseErrors(string command, string expectedInvalidTokens)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             IEnumerable<string> errorMessages = parseResult.Errors.Select(error => error.Message);
@@ -189,7 +189,7 @@ public void Search_HandleParseErrors(string command, string expectedInvalidToken
         public void Search_CanParseColumnsAll(string command)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -209,7 +209,7 @@ public void Search_CanParseColumnsAll(string command)
         public void Search_CanParseColumns(string command, string[] expectedColumns)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -231,7 +231,7 @@ public void Search_CanParseColumns(string command, string[] expectedColumns)
         public void Search_CannotParseUnknownColumns(string command)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
 
@@ -243,42 +243,42 @@ public void Search_CannotParseUnknownColumns(string command)
         public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             Command rootCommand = new("dotnet")
             {
                 myCommand
             };
 
             ParseResult parseResult = rootCommand.Parse("dotnet new search template");
-            Assert.Equal("dotnet new search my-template", Example.For<NewCommand>(parseResult).WithSubcommand<SearchCommand>().WithArgument(BaseSearchCommand.NameArgument, "my-template"));
+            Assert.Equal("dotnet new search my-template", Example.For<NewCommand>(parseResult).WithSubcommand<SearchCommand>().WithArgument(CommandDefinition.Search.NameArgument, "my-template"));
         }
 
         [Fact]
         public void CommandExampleShowsMandatoryArg()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             Command rootCommand = new("dotnet")
             {
                 myCommand
             };
 
             ParseResult parseResult = rootCommand.Parse("dotnet new search template");
-            Assert.Equal("dotnet new search [<template-name>]", Example.For<NewCommand>(parseResult).WithSubcommand<SearchCommand>().WithArgument(BaseSearchCommand.NameArgument));
+            Assert.Equal("dotnet new search [<template-name>]", Example.For<NewCommand>(parseResult).WithSubcommand<SearchCommand>().WithArgument(CommandDefinition.Search.NameArgument));
         }
 
         [Fact]
         public void CommandExampleShowsOptionalArgWhenOptionsAreGiven()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             Command rootCommand = new("dotnet")
             {
                 myCommand
             };
 
             ParseResult parseResult = rootCommand.Parse("dotnet new search template");
-            Assert.Equal("dotnet new search [<template-name>] --author Microsoft", Example.For<NewCommand>(parseResult).WithSubcommand<SearchCommand>().WithArgument(BaseSearchCommand.NameArgument).WithOption(SharedOptionsFactory.CreateAuthorOption(), "Microsoft"));
+            Assert.Equal("dotnet new search [<template-name>] --author Microsoft", Example.For<NewCommand>(parseResult).WithSubcommand<SearchCommand>().WithArgument(CommandDefinition.Search.NameArgument).WithOption(SharedOptionsFactory.CreateAuthorOption(), "Microsoft"));
         }
     }
 }
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs
index 94120f6f4b0f..0b42cbbcc0e6 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.Approval.cs
@@ -13,7 +13,7 @@ public partial class TabCompletionTests : BaseTest
         public Task RootCommand_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = ParserFactory.CreateParser(myCommand).Parse("new ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -25,7 +25,7 @@ public Task RootCommand_GetAllSuggestions()
         public Task RootCommand_GetStartsWtihSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new c");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -37,7 +37,7 @@ public Task RootCommand_GetStartsWtihSuggestions()
         public Task Install_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new install ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -49,7 +49,7 @@ public Task Install_GetAllSuggestions()
         public Task Uninstall_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new uninstall ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -61,7 +61,7 @@ public Task Uninstall_GetAllSuggestions()
         public Task Update_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new update ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -73,7 +73,7 @@ public Task Update_GetAllSuggestions()
         public Task List_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new list ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -85,7 +85,7 @@ public Task List_GetAllSuggestions()
         public Task Search_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new search ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -97,7 +97,7 @@ public Task Search_GetAllSuggestions()
         public Task Create_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new create ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -109,7 +109,7 @@ public Task Create_GetAllSuggestions()
         public Task TemplateCommand_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new console ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -121,7 +121,7 @@ public Task TemplateCommand_GetAllSuggestions()
         public Task DetailsCommand_GetAllSuggestions()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new details ");
             System.CommandLine.Completions.CompletionItem[] result = parseResult.GetCompletions().ToArray();
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs
index 6a0efd3511a9..59a270cd17ad 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TabCompletionTests.cs
@@ -20,7 +20,7 @@ public partial class TabCompletionTests
         public void Instantiate_CanSuggestTemplateOption_StartsWith()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new console --framework {ToolsetInfo.CurrentTargetFramework} --l");
             string[] suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -36,7 +36,7 @@ public void Instantiate_CanSuggestTemplateOption_StartsWith()
         public void Instantiate_CanSuggestLanguages()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new console --language ");
             string[] suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -53,7 +53,7 @@ public void Instantiate_CanSuggestLanguages()
         public void Install_GetSuggestionsAfterInteractive()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new install --interactive ");
             string[] result = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -66,7 +66,7 @@ public void Install_GetSuggestionsAfterInteractive()
         public void Install_GetSuggestionsAfterOptionWithoutArg()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new install --nuget-source ");
             CompletionItem[] result = parseResult.GetCompletions().ToArray();
@@ -80,7 +80,7 @@ public void Install_GetSuggestionsAfterOptionWithoutArg()
         public void Install_GetSuggestionsAfterOptionWithArg()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new install --nuget-source me");
             string[] result = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -93,7 +93,7 @@ public void Install_GetSuggestionsAfterOptionWithArg()
         public void Instantiate_CanSuggestTemplate_StartsWith()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            Command myCommand = NewCommandFactory.Create("new", _ => host);
+            Command myCommand = NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new co");
             string[] suggestions = parseResult.GetCompletions().Select(l => l.Label).ToArray();
@@ -115,7 +115,7 @@ public void CanCompleteChoice_FromSingleTemplate()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo --testChoice ");
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
             Assert.NotNull(completionContext);
@@ -144,7 +144,7 @@ public void CanCompleteChoice_MultichoiceTabCompletion(string command, string[]
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse(command);
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
             Assert.NotNull(completionContext);
@@ -169,7 +169,7 @@ public void CanCompleteChoice_FromSingleTemplate_StartsWith()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo --testChoice v");
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
             Assert.NotNull(completionContext);
@@ -193,7 +193,7 @@ public void CanCompleteChoice_FromSingleTemplate_InTheMiddle()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo --testChoice v --name test");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -221,7 +221,7 @@ public void CanCompleteChoice_FromMultipleTemplates()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo --testChoice ");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -248,7 +248,7 @@ public void CanCompleteChoice_FromMultipleTemplates_StartsWith()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo --testChoice v");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -277,7 +277,7 @@ public void CanCompleteParameters_FromMultipleTemplates()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo ");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -318,7 +318,7 @@ public void CanCompleteParameters_StartsWith_FromMultipleTemplates()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo --t");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -361,7 +361,7 @@ public void CanCompleteParameters_StartsWith_AfterOption()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo --foo val1 --bar val2 --t");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -402,7 +402,7 @@ public void CanCompleteLanguages(string optionName)
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo {optionName} ");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -429,7 +429,7 @@ public void CanCompleteTypes()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo --type ");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -460,7 +460,7 @@ public void CanIgnoreTemplateGroupsWithConstraints()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new fo");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -490,7 +490,7 @@ public void CanIgnoreTemplateGroupsWithConstraints_IgnoresLongEvaluationTemplate
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new fo");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -523,7 +523,7 @@ public void CanIgnoreTemplatesInGroupWithConstraints()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo ");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -558,7 +558,7 @@ public void IncludesTemplatesInGroupWithLongEvaluatedConstraints()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo ");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
@@ -592,7 +592,7 @@ public void WillNotEvaluateConstraints_WhenAtLeastOneTemplateInGroupDoesNotHaveC
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new fo");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
             var completionContext = parseResult.GetCompletionContext() as TextCompletionContext;
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TemplateCommandTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TemplateCommandTests.cs
index 6991a8cf427b..6f105a06e3fd 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TemplateCommandTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/TemplateCommandTests.cs
@@ -43,7 +43,7 @@ public Task CannotCreateCommandForInvalidParameter()
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
             TemplatePackageManager packageManager = A.Fake<TemplatePackageManager>();
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($" new foo");
             InstantiateCommandArgs args = InstantiateCommandArgs.FromNewCommandArgs(new NewCommandArgs(myCommand, parseResult));
 
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs
index 607f2dd2a7da..46c68a4b86a7 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UninstallTests.cs
@@ -16,7 +16,7 @@ public class UninstallTests : BaseTest
         public void Uninstall_NoArguments(string commandName)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new {commandName}");
             UninstallCommandArgs args = new((BaseUninstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -32,7 +32,7 @@ public void Uninstall_NoArguments(string commandName)
         public void Uninstall_WithArgument(string commandName)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new {commandName} source");
             UninstallCommandArgs args = new((BaseUninstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -49,7 +49,7 @@ public void Uninstall_WithArgument(string commandName)
         public void Uninstall_WithMultipleArgument(string command)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             UninstallCommandArgs args = new((BaseUninstallCommand)parseResult.CommandResult.Command, parseResult);
@@ -70,7 +70,7 @@ public void Uninstall_WithMultipleArgument(string command)
         public void Uninstall_CanReturnParseError(string command, string expectedInvalidTokens)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             IEnumerable<string> errorMessages = parseResult.Errors.Select(error => error.Message);
@@ -89,14 +89,14 @@ public void Uninstall_CanReturnParseError(string command, string expectedInvalid
         public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             Command rootCommand = new("dotnet")
             {
                 myCommand
             };
 
             ParseResult parseResult = rootCommand.Parse("dotnet new uninstall source");
-            Assert.Equal("dotnet new uninstall my-source", Example.For<NewCommand>(parseResult).WithSubcommand<UninstallCommand>().WithArgument(BaseUninstallCommand.NameArgument, "my-source"));
+            Assert.Equal("dotnet new uninstall my-source", Example.For<NewCommand>(parseResult).WithSubcommand<UninstallCommand>().WithArgument(CommandDefinition.Uninstall.NameArgument, "my-source"));
         }
     }
 }
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs
index 6fb3fe63d6ca..9e0cd1af5f6b 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/ParserTests/UpdateTests.cs
@@ -15,7 +15,7 @@ public class UpdateTests : BaseTest
         public void Update_CanParseAddSourceOption(string optionName)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new update {optionName} my-custom-source");
             UpdateCommandArgs args = new((UpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -32,7 +32,7 @@ public void Update_CanParseAddSourceOption(string optionName)
         public void Update_Error_WhenArguments(string commandName)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new {commandName} source");
 
@@ -46,7 +46,7 @@ public void Update_Error_WhenArguments(string commandName)
         public void Update_CanParseAddSourceOption_MultipleEntries(string testCase)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse(testCase);
             UpdateCommandArgs args = new((UpdateCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -60,7 +60,7 @@ public void Update_CanParseAddSourceOption_MultipleEntries(string testCase)
         public void Update_CanParseInteractiveOption()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new update --interactive");
             UpdateCommandArgs args = new((UpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -79,7 +79,7 @@ public void Update_CanParseInteractiveOption()
         public void Update_CanParseCheckOnlyOption(string optionAlias)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new update {optionAlias}");
             UpdateCommandArgs args = new((UpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -96,7 +96,7 @@ public void Update_CanParseCheckOnlyOption(string optionAlias)
         public void Update_Legacy_CanParseCheckOnlyOption()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new --update-check");
             UpdateCommandArgs args = new((LegacyUpdateCheckCommand)parseResult.CommandResult.Command, parseResult);
@@ -116,7 +116,7 @@ public void Update_Legacy_CanParseCheckOnlyOption()
         public void Update_Legacy_CanParseAddSourceOption(string testCase)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(testCase);
             UpdateCommandArgs args = new((BaseUpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -132,7 +132,7 @@ public void Update_Legacy_CanParseAddSourceOption(string testCase)
         public void Update_Legacy_CanParseInteractiveOption(string testCase)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(testCase);
             UpdateCommandArgs args = new((BaseUpdateCommand)parseResult.CommandResult.Command, parseResult);
@@ -147,7 +147,7 @@ public void Update_Legacy_CanParseInteractiveOption(string testCase)
         public void Update_Legacy_CanParseAddSourceOption_MultipleEntries(string testCase)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse(testCase);
             UpdateCommandArgs args = new((BaseUpdateCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -168,7 +168,7 @@ public void Update_Legacy_CanParseAddSourceOption_MultipleEntries(string testCas
         public void Update_CanReturnParseError(string command, string expectedInvalidTokens)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse(command);
             IEnumerable<string> errorMessages = parseResult.Errors.Select(error => error.Message);
@@ -187,7 +187,7 @@ public void Update_CanReturnParseError(string command, string expectedInvalidTok
         public void CommandExampleCanShowParentCommandsBeyondNew()
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             Command rootCommand = new("dotnet")
             {
                 myCommand
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplatePackageDisplayTest.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplatePackageDisplayTest.cs
index cc560fdefbea..e35147705969 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplatePackageDisplayTest.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplatePackageDisplayTest.cs
@@ -78,7 +78,7 @@ public async Task DisplayInstallResultTest_WithForceSpecified()
 
     Low:
         low1".UnixifyLineBreaks();
-            ParseResult parseResult = NewCommandFactory.Create("new", _ => CliTestHostFactory.GetVirtualHost()).Parse($"new search foo");
+            ParseResult parseResult = NewCommandFactory.Create(_ => CliTestHostFactory.GetVirtualHost()).Parse($"new search foo");
 
             await packageDisplayer.DisplayInstallResultAsync(
                 "PackageA",
@@ -125,7 +125,7 @@ public async Task DisplayInstallResultTest()
 In order to install this package, run:
    new install testPackage --force".UnixifyLineBreaks();
 
-            ParseResult parseResult = NewCommandFactory.Create("new", _ => CliTestHostFactory.GetVirtualHost()).Parse($"new search foo");
+            ParseResult parseResult = NewCommandFactory.Create(_ => CliTestHostFactory.GetVirtualHost()).Parse($"new search foo");
             await packageDisplayer.DisplayInstallResultAsync(
                 "testPackage",
                 installResult,
@@ -168,7 +168,7 @@ public async Task DisplayInstallResultTest_UpdateRequest()
    new uninstall testPackage
    new install testPackage --force".UnixifyLineBreaks();
 
-            ParseResult parseResult = NewCommandFactory.Create("new", _ => CliTestHostFactory.GetVirtualHost()).Parse($"new search foo");
+            ParseResult parseResult = NewCommandFactory.Create(_ => CliTestHostFactory.GetVirtualHost()).Parse($"new search foo");
             await packageDisplayer.DisplayInstallResultAsync(
                 "testPackage",
                 updateResult,
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs
index b9dee47fad62..7f926d104f1f 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateResolutionTests/ListTemplateResolverTests.cs
@@ -545,7 +545,7 @@ public async Task TestGetTemplateResolutionResult_ConstraintsMismatch()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: new[] { (typeof(ITemplateConstraintFactory), (IIdentifiedComponent)new TestConstraintFactory("test")) });
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new list");
             var args = new ListCommandArgs((ListCommand)parseResult.CommandResult.Command, parseResult);
@@ -576,7 +576,7 @@ public async Task TestGetTemplateResolutionResult_IgnoreConstraintsMismatch()
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: new[] { (typeof(ITemplateConstraintFactory), (IIdentifiedComponent)new TestConstraintFactory("test")) });
             IEngineEnvironmentSettings settings = new EngineEnvironmentSettings(host, virtualizeSettings: true);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse("new list --ignore-constraints");
             var args = new ListCommandArgs((ListCommand)parseResult.CommandResult.Command, parseResult);
@@ -597,7 +597,7 @@ private static ListCommandArgs GetListCommandArgsFor(string commandInput)
         {
             ICliTemplateEngineHost host = CliTestHostFactory.GetVirtualHost(additionalComponents: BuiltInTemplatePackagesProviderFactory.GetComponents(RepoTemplatePackages));
             RootCommand rootCommand = new();
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             rootCommand.Add(myCommand);
 
             ParseResult parseResult = rootCommand.Parse(commandInput);
diff --git a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateSearchCoordinatorTests.cs b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateSearchCoordinatorTests.cs
index a17a0f7fc4ae..14c50c34f3a2 100644
--- a/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateSearchCoordinatorTests.cs
+++ b/test/Microsoft.TemplateEngine.Cli.UnitTests/TemplateSearchCoordinatorTests.cs
@@ -73,7 +73,7 @@ public async Task CacheSearchNameMatchTest()
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new search foo");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -120,7 +120,7 @@ public async Task CacheSearchCliSymbolNameFilterTest()
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new search foo --framework netcoreapp2.0");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -164,7 +164,7 @@ public async Task CacheSearchCliSymbolNameMismatchFilterTest()
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new search foo --tfm netcoreapp2.0");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -203,7 +203,7 @@ public async Task CacheSearchLanguageFilterTest()
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new search bar --language F#");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -247,7 +247,7 @@ public async Task CacheSearchAuthorFilterTest(string commandTemplate, string com
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new search {commandTemplate} --author {commandAuthor}");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -288,7 +288,7 @@ public async Task CacheSearchTypeFilterTest(string commandTemplate, string comma
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new search {commandTemplate} --type {commandType}");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
@@ -331,7 +331,7 @@ public async Task CacheSearchPackageFilterTest(string commandTemplate, string co
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
 
             ParseResult parseResult = myCommand.Parse($"new search {commandTemplate} --package {commandPackage}");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
@@ -379,7 +379,7 @@ public async Task CacheSearchTagFilterTest(string commandTemplate, string comman
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new search {commandTemplate} --tag {commandTag}");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -421,7 +421,7 @@ public async Task CacheSearchLanguageMismatchFilterTest()
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new search bar --language VB");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
 
@@ -458,7 +458,7 @@ public async Task CacheSkipInvalidTemplatesTest()
             var engineEnvironmentSettings = new EngineEnvironmentSettings(host, virtualizeSettings: true, environment: environment);
             var templatePackageManager = new TemplatePackageManager(engineEnvironmentSettings);
 
-            NewCommand myCommand = (NewCommand)NewCommandFactory.Create("new", _ => host);
+            NewCommand myCommand = (NewCommand)NewCommandFactory.Create(_ => host);
             ParseResult parseResult = myCommand.Parse($"new search --unknown");
             SearchCommandArgs args = new((SearchCommand)parseResult.CommandResult.Command, parseResult);
 

From 0ab0790d1e54eb7b238895b0ea13960342e6c68b Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Fri, 14 Nov 2025 15:35:02 -0800
Subject: [PATCH 2/4] Move

---
 .../{Commands => CommandDefinitions}/SharedOptions.cs             | 0
 .../{Commands => CommandDefinitions}/SharedOptionsFactory.cs      | 0
 2 files changed, 0 insertions(+), 0 deletions(-)
 rename src/Cli/Microsoft.TemplateEngine.Cli/{Commands => CommandDefinitions}/SharedOptions.cs (100%)
 rename src/Cli/Microsoft.TemplateEngine.Cli/{Commands => CommandDefinitions}/SharedOptionsFactory.cs (100%)

diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/SharedOptions.cs
similarity index 100%
rename from src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptions.cs
rename to src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/SharedOptions.cs
diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptionsFactory.cs b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/SharedOptionsFactory.cs
similarity index 100%
rename from src/Cli/Microsoft.TemplateEngine.Cli/Commands/SharedOptionsFactory.cs
rename to src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/SharedOptionsFactory.cs

From 0e4129bee6bc95442b2c47744ae92fbac9e4fb86 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Sat, 15 Nov 2025 12:58:29 -0800
Subject: [PATCH 3/4] Fixes

---
 .../CommandDefinitions/CommandDefinition.cs   | 27 +++++++++++++------
 1 file changed, 19 insertions(+), 8 deletions(-)

diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinition.cs b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinition.cs
index 333eb9364256..a65d0a8d2009 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinition.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/CommandDefinitions/CommandDefinition.cs
@@ -177,9 +177,9 @@ private static CommandDefinition Create()
             return command;
         }
 
-        internal static IReadOnlyDictionary<FilterOptionDefinition, Option> CreateFilterOptions(IEnumerable<FilterOptionDefinition> supportedFilters, bool isLegacy)
+        internal static OrderedDictionary<FilterOptionDefinition, Option> CreateFilterOptions(IEnumerable<FilterOptionDefinition> supportedFilters, bool isLegacy)
         {
-            var filterOptionsMap = new Dictionary<FilterOptionDefinition, Option>();
+            var filterOptionsMap = new OrderedDictionary<FilterOptionDefinition, Option>();
 
             foreach (var filterDef in supportedFilters)
             {
@@ -232,8 +232,17 @@ public static class Show
 
     public static class Instantiate
     {
-        public static readonly Argument<string> ShortNameArgument = New.ShortNameArgument;
-        public static readonly Argument<string[]> RemainingArguments = New.RemainingArguments;
+        public static readonly Argument<string> ShortNameArgument = new("template-short-name")
+        {
+            Description = SymbolStrings.Command_Instantiate_Argument_ShortName,
+            Arity = new ArgumentArity(0, 1)
+        };
+
+        public static readonly Argument<string[]> RemainingArguments = new("template-args")
+        {
+            Description = SymbolStrings.Command_Instantiate_Argument_TemplateOptions,
+            Arity = new ArgumentArity(0, 999)
+        };
 
         public static readonly CommandDefinition Command = new CommandDefinition("create", SymbolStrings.Command_Instantiate_Description)
         {
@@ -390,7 +399,7 @@ public sealed class List : CommandDefinition
         public Option<bool> ColumnsAllOption { get; }
         public Option<string[]> ColumnsOption { get; }
 
-        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; }
+        public OrderedDictionary<FilterOptionDefinition, Option> Filters { get; }
 
         public List(string name, bool isLegacy)
             : base(name, SymbolStrings.Command_List_Description)
@@ -402,6 +411,8 @@ public List(string name, bool isLegacy)
 
             Arguments.Add(NameArgument);
 
+            Options.AddRange(Filters.Values);
+
             Options.AddRange(
             [
                 IgnoreConstraintsOption,
@@ -411,7 +422,6 @@ public List(string name, bool isLegacy)
                 ColumnsOption,
             ]);
 
-            Options.AddRange(Filters.Values);
             this.AddNoLegacyUsageValidators(isLegacy ? [.. Filters.Values, ColumnsAllOption, ColumnsOption, New.ShortNameArgument] : []);
         }
     }
@@ -446,7 +456,7 @@ public sealed class Search : CommandDefinition
         public Option<bool> ColumnsAllOption { get; }
         public Option<string[]> ColumnsOption { get; }
 
-        public IReadOnlyDictionary<FilterOptionDefinition, Option> Filters { get; }
+        public OrderedDictionary<FilterOptionDefinition, Option> Filters { get; }
 
         public Search(string name, bool isLegacy)
             : base(name, SymbolStrings.Command_Search_Description)
@@ -458,13 +468,14 @@ public Search(string name, bool isLegacy)
 
             Arguments.Add(NameArgument);
 
+            Options.AddRange(Filters.Values);
+
             Options.AddRange(
             [
                 ColumnsAllOption,
                 ColumnsOption,
             ]);
 
-            Options.AddRange(Filters.Values);
             this.AddNoLegacyUsageValidators(isLegacy ? [.. Filters.Values, ColumnsAllOption, ColumnsOption, New.ShortNameArgument] : []);
         }
     }

From 3ad3e29c00fa792953f35297a685791322712a73 Mon Sep 17 00:00:00 2001
From: Tomas Matousek <tomat@microsoft.com>
Date: Sun, 16 Nov 2025 10:10:04 -0800
Subject: [PATCH 4/4] Fix

---
 src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
index d43849972c60..a6d7dfc8e9bd 100644
--- a/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
+++ b/src/Cli/Microsoft.TemplateEngine.Cli/Commands/BaseCommand.cs
@@ -118,7 +118,7 @@ protected internal static async Task CheckTemplatesWithSubCommandName(
             }
 
             Reporter.Output.WriteLine(LocalizableStrings.Commands_TemplateShortNameCommandConflict_Info, usedCommandAlias);
-            Reporter.Output.WriteCommand(Example.For<InstantiateCommand>(args.ParseResult).WithArgument(CommandDefinition.New.ShortNameArgument, usedCommandAlias));
+            Reporter.Output.WriteCommand(Example.For<InstantiateCommand>(args.ParseResult).WithArgument(CommandDefinition.Instantiate.ShortNameArgument, usedCommandAlias));
             Reporter.Output.WriteLine();
         }