Improve EXE metadata defaults and CLI aliases (#114)

Author: SuperJMN

src/DotnetPackaging.Exe/ExePackagingService.cs

@@ -8,6 +8,7 @@
 using System.Security.Cryptography;
 using System.Reflection;
 using CSharpFunctionalExtensions;
+using DotnetPackaging;
 using DotnetPackaging.Publish;
 using Serilog;
 using RuntimeArchitecture = System.Runtime.InteropServices.Architecture;
@@ -55,7 +56,8 @@ public Task<Result<FileInfo>> BuildFromDirectory(
             ToMaybe(vendor),
             ToMaybe(runtimeIdentifier),
             ToMaybe(stubFile),
-            Maybe<string>.None);
+            Maybe<string>.None,
+            Maybe<ProjectMetadata>.None);
 
         return Build(request);
     }
@@ -87,22 +89,46 @@ public async Task<Result<FileInfo>> BuildFromProject(
             return Result.Failure<FileInfo>(publishResult.Error);
         }
 
+        var projectMetadata = ReadProjectMetadata(projectFile);
+
         var request = new ExePackagingRequest(
             new DirectoryInfo(publishResult.Value.OutputDirectory),
             outputFile,
             options,
             ToMaybe(vendor),
             ToMaybe(runtimeIdentifier),
             ToMaybe(stubFile),
-            publishResult.Value.Name);
+            publishResult.Value.Name,
+            projectMetadata);
 
         return await Build(request);
     }
 
+    private Maybe<ProjectMetadata> ReadProjectMetadata(FileInfo projectFile)
+    {
+        var metadataResult = ProjectMetadataReader.Read(projectFile);
+        if (metadataResult.IsFailure)
+        {
+            logger.Warning(
+                "Unable to read project metadata from {ProjectFile}: {Error}",
+                projectFile.FullName,
+                metadataResult.Error);
+            return Maybe<ProjectMetadata>.None;
+        }
+
+        return Maybe<ProjectMetadata>.From(metadataResult.Value);
+    }
+
     private async Task<Result<FileInfo>> Build(ExePackagingRequest request)
     {
         var inferredExecutable = InferExecutableName(request.PublishDirectory, request.ProjectName);
-        var metadata = BuildInstallerMetadata(request.Options, request.PublishDirectory, request.Vendor, inferredExecutable, request.ProjectName);
+        var metadata = BuildInstallerMetadata(
+            request.Options,
+            request.PublishDirectory,
+            request.Vendor,
+            inferredExecutable,
+            request.ProjectName,
+            request.ProjectMetadata);
 
         if (request.Stub.HasValue)
         {
@@ -186,10 +212,17 @@ private static InstallerMetadata BuildInstallerMetadata(
         DirectoryInfo contextDir,
         Maybe<string> vendor,
         Maybe<string> inferredExecutable,
-        Maybe<string> projectName)
+        Maybe<string> projectName,
+        Maybe<ProjectMetadata> projectMetadata)
     {
-        // Prefer explicit --application-name, then project name (when packaging from-project), then publish directory name
+        var metadataProduct = projectMetadata
+            .Bind(meta => meta.Product
+                .Or(() => meta.AssemblyName)
+                .Or(() => meta.AssemblyTitle));
+
+        // Prefer explicit --application-name, then project metadata, then project name (from publish), then publish directory name
         var appName = options.Name
+            .Or(() => metadataProduct)
             .Or(() => projectName)
             .GetValueOrDefault(contextDir.Name);
         var packageName = appName.ToLowerInvariant().Replace(" ", string.Empty).Replace("-", string.Empty);
@@ -199,7 +232,15 @@ private static InstallerMetadata BuildInstallerMetadata(
             .Or(() => inferredExecutable)
             .Map(NormalizeExecutableRelativePath)
             .Match(value => value, () => (string?)null);
-        var effectiveVendor = vendor.Match(value => value, () => "Unknown");
+        var vendorFromProject = projectMetadata
+            .Bind(meta => meta.Company
+                .Or(() => meta.Product)
+                .Or(() => meta.AssemblyName)
+                .Or(() => meta.AssemblyTitle));
+
+        var effectiveVendor = vendor
+            .Or(() => vendorFromProject)
+            .GetValueOrDefault("Unknown");
         var description = options.Comment.Match(value => value, () => (string?)null);
 
         return new InstallerMetadata(appId, appName, version, effectiveVendor, description, executable);
@@ -747,5 +788,6 @@ private sealed record ExePackagingRequest(
         Maybe<string> Vendor,
         Maybe<string> RuntimeIdentifier,
         Maybe<FileInfo> Stub,
-        Maybe<string> ProjectName);
+        Maybe<string> ProjectName,
+        Maybe<ProjectMetadata> ProjectMetadata);
 }

src/DotnetPackaging.Tool/Program.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.CommandLine;
 using System.CommandLine.Parsing;
 using System.Diagnostics;
@@ -35,6 +36,7 @@ public static async Task<int> Main(string[] args)
         Environment.ExitCode = 0;
         var verboseEnabled = IsVerboseRequested(args);
         SetVerboseEnvironment(verboseEnabled);
+        var normalizedArgs = NormalizeMetadataAliases(args);
 
         var levelSwitch = new LoggingLevelSwitch(verboseEnabled ? LogEventLevel.Debug : LogEventLevel.Information);
 
@@ -351,7 +353,7 @@ await ExecuteWithLogging("exe-from-project", extrasOutput.FullName, async logger
 
         rootCommand.Add(exeCommand);
 
-        var parseResult = rootCommand.Parse(args, configuration: null);
+        var parseResult = rootCommand.Parse(normalizedArgs, configuration: null);
         var exitCode = await parseResult.InvokeAsync(parseResult.InvocationConfiguration, CancellationToken.None);
         var finalExitCode = Environment.ExitCode != 0 ? Environment.ExitCode : exitCode;
         Environment.ExitCode = finalExitCode;
@@ -395,6 +397,43 @@ private static void SetVerboseEnvironment(bool verbose)
         Environment.SetEnvironmentVariable(VerboseEnvVar, verbose ? "1" : "0");
     }
 
+    private static string[] NormalizeMetadataAliases(string[] args)
+    {
+        if (args.Length == 0)
+        {
+            return args;
+        }
+
+        var replacements = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
+        {
+            ["--productName"] = "--application-name",
+            ["--appName"] = "--application-name",
+            ["--company"] = "--vendor"
+        };
+
+        var normalized = new string[args.Length];
+        for (var i = 0; i < args.Length; i++)
+        {
+            var token = args[i];
+            if (token.StartsWith("--", StringComparison.Ordinal))
+            {
+                var separatorIndex = token.IndexOf('=');
+                var key = separatorIndex >= 0 ? token[..separatorIndex] : token;
+                if (replacements.TryGetValue(key, out var replacement))
+                {
+                    normalized[i] = separatorIndex >= 0
+                        ? string.Concat(replacement, token[separatorIndex..])
+                        : replacement;
+                    continue;
+                }
+            }
+
+            normalized[i] = token;
+        }
+
+        return normalized;
+    }
+
     private static Command CreateCommand(
         string commandName,
         string friendlyName,

src/DotnetPackaging/ProjectMetadata.cs

@@ -0,0 +1,50 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Xml.Linq;
+using CSharpFunctionalExtensions;
+
+namespace DotnetPackaging;
+
+public sealed record ProjectMetadata(
+    Maybe<string> Product,
+    Maybe<string> Company,
+    Maybe<string> AssemblyName,
+    Maybe<string> AssemblyTitle);
+
+public static class ProjectMetadataReader
+{
+    public static Result<ProjectMetadata> Read(FileInfo projectFile)
+    {
+        if (!projectFile.Exists)
+        {
+            return Result.Failure<ProjectMetadata>($"Project file not found: {projectFile.FullName}");
+        }
+
+        return Result.Try(() =>
+        {
+            var document = XDocument.Load(projectFile.FullName);
+            var product = ReadProperty(document, "Product");
+            var company = ReadProperty(document, "Company");
+            var assemblyName = ReadProperty(document, "AssemblyName");
+            var assemblyTitle = ReadProperty(document, "AssemblyTitle");
+
+            return new ProjectMetadata(product, company, assemblyName, assemblyTitle);
+        }, ex => $"Failed to read project metadata from {projectFile.FullName}: {ex.Message}");
+    }
+
+    private static Maybe<string> ReadProperty(XDocument document, string propertyName)
+    {
+        var element = document
+            .Descendants()
+            .FirstOrDefault(x => string.Equals(x.Name.LocalName, propertyName, StringComparison.OrdinalIgnoreCase));
+
+        if (element is null)
+        {
+            return Maybe<string>.None;
+        }
+
+        var value = element.Value?.Trim();
+        return string.IsNullOrWhiteSpace(value) ? Maybe<string>.None : Maybe<string>.From(value);
+    }
+}