Add info command to display key information

doc/settings.md

@@ -21,7 +21,7 @@ If set to true, the `telemetry.disable` setting will prevent any event from bein
 
 ## CleanUp
 
-The `CleanUp` settings determine whether Winget-Create will handle the removal of temporary files (installer cache and logs) generated during the manifest creation process. These settings provide control over the decision to remove files or not and the frequency at which this clean up occurs.
+The `CleanUp` settings determine whether Winget-Create will handle the removal of temporary files i.e., installers downloaded and logs generated during the manifest creation process. You can view the location of these files using `wingetcreate --info` command. These settings provide control over the decision to remove files or not and the frequency at which this clean up occurs.
 
 ### disable
 
@@ -60,3 +60,17 @@ The `name` setting specifies the name of the targeted GitHub repository. By defa
     "name": "winget-pkgs"
   }
 ```
+
+## Visual
+
+The `Visual` settings control the appearance of the Winget-Create CLI output.
+
+### anonymizePaths
+
+The `anonymizePaths` setting controls whether the paths of files and directories are anonymized in the Winget-Create CLI output. This means that a path such as `C:\Users\user\Documents\manifests\` will be displayed as `%USERPROFILE%\Documents\manifests` (i.e., substitute environment variables where possible). By default, this is set to `true`.
+
+```json
+    "Visual": {
+        "anonymizePaths": true
+    }
+```

src/WingetCreateCLI/Commands/BaseCommand.cs

@@ -194,7 +194,7 @@ protected static string SaveManifestDirToLocalPath(
             }
 
             Console.WriteLine();
-            Logger.InfoLocalized(nameof(Resources.ManifestSaved_Message), fullDirPath);
+            Logger.InfoLocalized(nameof(Resources.ManifestSaved_Message), Common.GetPathForDisplay(fullDirPath, UserSettings.AnonymizePaths));
             Console.WriteLine();
 
             return fullDirPath;

src/WingetCreateCLI/Common.cs

@@ -13,6 +13,9 @@ namespace Microsoft.WingetCreateCLI
     public static class Common
     {
         private const string ModuleName = "WindowsPackageManagerManifestCreator";
+        private const string UserProfileEnvironmentVariable = "%USERPROFILE%";
+        private const string LocalAppDataEnvironmentVariable = "%LOCALAPPDATA%";
+        private const string TempEnvironmentVariable = "%TEMP%";
 
         private static readonly Lazy<string> AppStatePathLazy = new(() =>
         {
@@ -61,6 +64,39 @@ public static void CleanUpFilesOlderThan(string cleanUpDirectory, int cleanUpDay
             }
         }
 
+        /// <summary>
+        /// Gets the path for display. This will anonymize the path if caller provides the appropriate flag.
+        /// </summary>
+        /// <param name="path">Path to be displayed.</param>
+        /// <param name="substitueEnvironmentVariables">Whether or not to substitute environment variables.</param>
+        /// <returns>Anonymized path or original path.</returns>
+        public static string GetPathForDisplay(string path, bool substitueEnvironmentVariables = true)
+        {
+            if (string.IsNullOrEmpty(path) || !substitueEnvironmentVariables)
+            {
+                return path;
+            }
+
+            string userProfilePath = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
+            string localAppDataPath = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
+            string tempPath = Path.GetTempPath();
+
+            if (path.StartsWith(tempPath, StringComparison.OrdinalIgnoreCase))
+            {
+                return path.Replace(tempPath, TempEnvironmentVariable + Path.DirectorySeparatorChar, StringComparison.OrdinalIgnoreCase);
+            }
+            else if (path.StartsWith(localAppDataPath, StringComparison.OrdinalIgnoreCase))
+            {
+                return path.Replace(localAppDataPath, LocalAppDataEnvironmentVariable, StringComparison.OrdinalIgnoreCase);
+            }
+            else if (path.StartsWith(userProfilePath, StringComparison.OrdinalIgnoreCase))
+            {
+                return path.Replace(userProfilePath, UserProfileEnvironmentVariable, StringComparison.OrdinalIgnoreCase);
+            }
+
+            return path;
+        }
+
         private static bool IsRunningAsUwp()
         {
             DesktopBridge.Helpers helpers = new DesktopBridge.Helpers();

src/WingetCreateCLI/Models/SettingsModel.cs

@@ -48,6 +48,17 @@ public partial class WindowsPackageManagerRepository
         public string Name { get; set; } = "winget-pkgs";
 
 
+    }
+
+    /// <summary>Visual settings</summary>
+    [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "10.4.3.0 (Newtonsoft.Json v11.0.0.0)")]
+    public partial class Visual 
+    {
+        /// <summary>Controls whether paths displayed on the console are substituted with environment variables</summary>
+        [Newtonsoft.Json.JsonProperty("anonymizePaths", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        public bool AnonymizePaths { get; set; } = true;
+
+
     }
 
     [System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "10.4.3.0 (Newtonsoft.Json v11.0.0.0)")]
@@ -69,6 +80,10 @@ public partial class SettingsManifest
         [System.ComponentModel.DataAnnotations.Required]
         public WindowsPackageManagerRepository WindowsPackageManagerRepository { get; set; } = new WindowsPackageManagerRepository();
 
+        [Newtonsoft.Json.JsonProperty("Visual", Required = Newtonsoft.Json.Required.DisallowNull, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
+        [System.ComponentModel.DataAnnotations.Required]
+        public Visual Visual { get; set; } = new Visual();
+
 
     }
-}
+}

src/WingetCreateCLI/Program.cs

@@ -22,6 +22,18 @@ namespace Microsoft.WingetCreateCLI
     /// </summary>
     internal class Program
     {
+        /// <summary>
+        /// Displays the application header and the copyright.
+        /// </summary>
+        public static void DisplayApplicationHeaderAndCopyright()
+        {
+            Console.WriteLine(string.Format(
+                Resources.Heading,
+                Utils.GetEntryAssemblyVersion()) +
+                Environment.NewLine +
+                Constants.MicrosoftCopyright);
+        }
+
         private static async Task<int> Main(string[] args)
         {
             Logger.Initialize();
@@ -48,25 +60,46 @@ private static async Task<int> Main(string[] args)
                 typeof(CacheCommand),
                 typeof(ShowCommand),
             };
-            var parserResult = myParser.ParseArguments(args, types);
 
-            BaseCommand command = parserResult.MapResult(c => c as BaseCommand, err => null);
+            var baseCommandsParserResult = myParser.ParseArguments(args, types);
+            BaseCommand parsedCommand = baseCommandsParserResult.MapResult(c => c as BaseCommand, err => null);
 
-            if (command == null)
+            if (parsedCommand == null)
             {
-                DisplayHelp(parserResult as NotParsed<object>);
-                DisplayParsingErrors(parserResult as NotParsed<object>);
+                // In case of unsuccessful parsing, check if user tried to run a valid command.
+                bool isBaseCommand = baseCommandsParserResult.TypeInfo.Current.BaseType.Equals(typeof(BaseCommand));
+
+                /* Parse root options.
+                 * Adding '--help' is a workaround to force parser to display the options help text when no arguments are passed.
+                 * This makes rootOptionsParserResult to be a NotParsed object which makes HelpText.AutoBuild print the correct help text.
+                 * This is done since the parser does not print the correct help text on a successful parse.
+                  */
+                ParserResult<RootOptions> rootOptionsParserResult = myParser.ParseArguments<RootOptions>(
+                    args.Length == 0 ? new string[] { "--help" } : args);
+
+                if (!isBaseCommand)
+                {
+                    rootOptionsParserResult.WithParsed(RootOptions.ParseRootOptions);
+
+                    if (rootOptionsParserResult.Tag == ParserResultType.Parsed)
+                    {
+                        return 0;
+                    }
+                }
+
+                DisplayHelp(baseCommandsParserResult as NotParsed<object>, isBaseCommand ? null : rootOptionsParserResult as NotParsed<RootOptions>);
+                DisplayParsingErrors(baseCommandsParserResult as NotParsed<object>);
                 return args.Any() ? 1 : 0;
             }
 
-            if (command is not SettingsCommand && command is not CacheCommand)
+            if (parsedCommand is not SettingsCommand && parsedCommand is not CacheCommand)
             {
                 // Do not load github client for settings or cache command.
-                if (await command.LoadGitHubClient())
+                if (await parsedCommand.LoadGitHubClient())
                 {
                     try
                     {
-                        string latestVersion = await command.GitHubClient.GetLatestRelease();
+                        string latestVersion = await parsedCommand.GitHubClient.GetLatestRelease();
                         string trimmedVersion = latestVersion.TrimStart('v').Split('-').First();
                         if (trimmedVersion != Utils.GetEntryAssemblyVersion())
                         {
@@ -84,7 +117,7 @@ private static async Task<int> Main(string[] args)
                 else
                 {
                     // Do not block creating a new manifest if loading the GitHub client fails. InstallerURL could point to a local network.
-                    if (command is not NewCommand)
+                    if (parsedCommand is not NewCommand)
                     {
                         return 1;
                     }
@@ -94,7 +127,7 @@ private static async Task<int> Main(string[] args)
             try
             {
                 WingetCreateCore.Serialization.ProducedBy = string.Join(" ", Constants.ProgramName, Utils.GetEntryAssemblyVersion());
-                return await command.Execute() ? 0 : 1;
+                return await parsedCommand.Execute() ? 0 : 1;
             }
             catch (Exception ex)
             {
@@ -118,28 +151,66 @@ private static async Task<int> Main(string[] args)
             }
         }
 
-        private static void DisplayHelp(NotParsed<object> result)
+        private static void DisplayHelp(NotParsed<object> baseCommandsParserResult, ParserResult<RootOptions> rootOptionsParserResult)
+        {
+            DisplayApplicationHeaderAndCopyright();
+            DisplayCommandsHelpText(baseCommandsParserResult);
+            if (rootOptionsParserResult != null)
+            {
+                DisplayRootOptionsHelpText(rootOptionsParserResult);
+            }
+
+            DisplayFooter();
+        }
+
+        private static void DisplayCommandsHelpText(NotParsed<object> result)
         {
             var helpText = HelpText.AutoBuild(
-                result,
-                h =>
-                {
-                    h.AddDashesToOption = true;
-                    h.AdditionalNewLineAfterOption = false;
-                    h.Heading = string.Format(Resources.Heading, Utils.GetEntryAssemblyVersion()) + Environment.NewLine;
-                    h.Copyright = Constants.MicrosoftCopyright;
-                    h.AddNewLineBetweenHelpSections = true;
-                    h.AddPreOptionsLine(Resources.AppDescription_HelpText);
-                    h.AddPostOptionsLines(new string[] { Resources.MoreHelp_HelpText, Resources.PrivacyStatement_HelpText });
-                    h.MaximumDisplayWidth = 100;
-                    h.AutoHelp = false;
-                    h.AutoVersion = false;
-                    return h;
-                },
-                e => e,
-                verbsIndex: true);
+            result,
+            h =>
+            {
+                h.AddDashesToOption = true;
+                h.AdditionalNewLineAfterOption = false;
+                h.Heading = string.Empty;
+                h.Copyright = string.Empty;
+                h.AddNewLineBetweenHelpSections = true;
+                h.AddPreOptionsLine(Resources.AppDescription_HelpText);
+                h.AddPreOptionsLine(Environment.NewLine);
+                h.AddPreOptionsLine(Resources.CommandsAvailable_Message);
+                h.MaximumDisplayWidth = 100;
+                h.AutoHelp = false;
+                h.AutoVersion = false;
+                return h;
+            },
+            e => e,
+            verbsIndex: true);
+            Console.WriteLine(helpText);
+        }
+
+        private static void DisplayRootOptionsHelpText(ParserResult<RootOptions> result)
+        {
+            var helpText = HelpText.AutoBuild(
+            result,
+            h =>
+            {
+                h.AddDashesToOption = true;
+                h.AdditionalNewLineAfterOption = false;
+                h.Heading = Resources.OptionsAvailable_Message;
+                h.Copyright = string.Empty;
+                h.AddNewLineBetweenHelpSections = false;
+                h.MaximumDisplayWidth = 100;
+                h.AutoHelp = false;
+                h.AutoVersion = false;
+                return h;
+            },
+            e => e);
             Console.WriteLine(helpText);
-            Console.WriteLine();
+        }
+
+        private static void DisplayFooter()
+        {
+            Console.WriteLine(Resources.MoreHelp_HelpText);
+            Console.WriteLine(Resources.PrivacyStatement_HelpText);
         }
 
         private static void DisplayParsingErrors<T>(NotParsed<T> result)