Use System.CommandLine.Experimental instead of NDesk.Options

src/Pretzel.Logic/Commands/BakeBaseCommandArguments.cs

@@ -0,0 +1,23 @@
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.IO.Abstractions;
+
+namespace Pretzel.Logic.Commands
+{
+    public abstract class BakeBaseCommandArguments : PretzelBaseCommandArguments
+    {
+        protected BakeBaseCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
+
+        protected override IEnumerable<Option> CreateOptions() => base.CreateOptions().Concat(new[]
+        {
+            new Option(new [] { "-c", "--cleantarget" }, "Delete the target directory (_site by default)")
+            {
+                Argument = new Argument<bool>()
+            },
+        });
+
+        public bool CleanTarget { get; set; }
+    }
+}

src/Pretzel.Logic/Commands/BakeCommand.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using System.Composition;
+using System.Diagnostics;
+using System.IO.Abstractions;
+using System.Linq;
+using System.Threading.Tasks;
+using Pretzel.Logic.Extensibility;
+using Pretzel.Logic.Extensions;
+using Pretzel.Logic.Templating.Context;
+
+namespace Pretzel.Logic.Commands
+{
+    [Shared]
+    [Export]
+    [CommandArguments]
+    public sealed class BakeCommandArguments : BakeBaseCommandArguments
+    {
+        [ImportingConstructor]
+        public BakeCommandArguments(IFileSystem fileSystem) : base(fileSystem) { }
+    }
+
+    [Shared]
+    [CommandInfo(
+        Name = "bake",
+        Description = "transforming content into a website",
+        ArgumentsType = typeof(BakeCommandArguments),
+        CommandType = typeof(BakeCommand)
+        )]
+    public sealed class BakeCommand : Command<BakeCommandArguments>
+    {
+        [Import]
+        public TemplateEngineCollection TemplateEngines { get; set; }
+
+        [Import]
+        public SiteContextGenerator Generator { get; set; }
+
+        [ImportMany]
+        public IEnumerable<ITransform> Transforms { get; set; }
+
+        [Import]
+        public IFileSystem FileSystem { get; set; }
+
+        protected override Task<int> Execute(BakeCommandArguments arguments)
+        {
+            Tracing.Info("bake - transforming content into a website");
+
+            var siteContext = Generator.BuildContext(arguments.Source, arguments.Destination, arguments.Drafts);
+
+            if (arguments.CleanTarget && FileSystem.Directory.Exists(siteContext.OutputFolder))
+            {
+                FileSystem.Directory.Delete(siteContext.OutputFolder, true);
+            }
+
+            if (string.IsNullOrWhiteSpace(arguments.Template))
+            {
+                arguments.DetectFromDirectory(TemplateEngines.Engines, siteContext);
+            }
+
+            var engine = TemplateEngines[arguments.Template];
+            if (engine != null)
+            {
+                var watch = new Stopwatch();
+                watch.Start();
+                engine.Initialize();
+                engine.Process(siteContext);
+                foreach (var t in Transforms)
+                    t.Transform(siteContext);
+
+                engine.CompressSitemap(siteContext, FileSystem);
+
+                watch.Stop();
+                Tracing.Info("done - took {0}ms", watch.ElapsedMilliseconds);
+            }
+            else
+            {
+                Tracing.Info("Cannot find engine for input: '{0}'", arguments.Template);
+                return Task.FromResult(1);
+            }
+            return Task.FromResult(0);
+        }
+    }
+}

src/Pretzel.Logic/Commands/BaseCommandArguments.cs

@@ -0,0 +1,28 @@
+using Pretzel.Logic.Extensibility;
+using System;
+using System.Collections.Generic;
+using System.CommandLine;
+using System.Composition;
+using System.Linq;
+
+namespace Pretzel.Logic.Commands
+{
+    public abstract class BaseCommandArguments : ICommandArguments
+    {
+        readonly List<Option> options = new List<Option>();
+        [Export]
+        public IList<Option> Options => options;
+        public IList<ICommandArgumentsExtension> Extensions { get; } = new List<ICommandArgumentsExtension>();
+
+        internal void BuildOptions()
+        {
+            options.AddRange(CreateOptions());
+        }
+
+        protected abstract IEnumerable<Option> CreateOptions();
+
+        public virtual void BindingCompleted()
+        {
+        }
+    }
+}

src/Pretzel.Logic/Commands/CommandArgumentsAttribute.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Composition;
+
+namespace Pretzel.Logic.Commands
+{
+    [MetadataAttribute]
+    [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
+    public sealed class CommandArgumentsAttribute : ExportAttribute
+    {
+        public CommandArgumentsAttribute() : base(typeof(ICommandArguments))
+        {
+        }
+    }
+}

src/Pretzel/Commands/CommandInfoAttribute.cs → src/Pretzel.Logic/Commands/CommandInfoAttribute.cs

@@ -1,13 +1,19 @@
 using System;
 using System.Composition;
 
-namespace Pretzel.Commands
+namespace Pretzel.Logic.Commands
 {
     [MetadataAttribute]
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = false)]
     public sealed class CommandInfoAttribute : ExportAttribute
     {
-        public string CommandName { get; set; }
+        public string Name { get; set; }
+
+        public string Description { get; set; }
+
+        public Type ArgumentsType { get; set; }
+
+        public Type CommandType { get; set; }
 
         public CommandInfoAttribute() : base(typeof(ICommand))
         {