Implement PostPageGenerator and PostPageCommand

- Implemented PostPageGenerator with 3 partial files:
  - PostPageGenerator.Markdown.cs: ParseMarkdown, TransformMarkdown, ParseFrontmatter
  - PostPageGenerator.Template.cs: ResolveTemplate, CopyAssets, RenderTemplate
  - PostPageGenerator.cs: CreateDataModel, CreateOutputFolder, WriteIndexHtml, GenerateAsync orchestrator

- Implemented PostPageCommand with CLI interface:
  - 4 options: --markdown, --template, --output, --template-file
  - Path resolution using SystemFile/SystemFolder constructors
  - Template type detection via Directory.Exists
  - Generator invocation with proper error handling

- Applied all 12 gap resolutions from planning:
  - Markdig Advanced Extensions, YamlDotNet error handling, template conventions
  - DepthFirstRecursiveFolder for asset copying, path sanitization
  - Exception-based error handling, silent overwrite behavior

- Ready for testing & validation

Author: Arlodotexe

src/Blog/PostPage/PostPageDataModel.cs

@@ -0,0 +1,48 @@
+using System;
+using System.Collections.Generic;
+
+namespace WindowsAppCommunity.Blog.PostPage
+{
+    /// <summary>
+    /// Data model for Scriban template rendering in Post/Page scenario.
+    /// Provides the data contract that templates can access via dot notation.
+    /// </summary>
+    public class PostPageDataModel
+    {
+        /// <summary>
+        /// Transformed HTML content from markdown body.
+        /// Generated via Markdig pipeline, ready to insert into template.
+        /// No wrapping elements - template controls structure.
+        /// </summary>
+        public string Body { get; set; } = string.Empty;
+
+        /// <summary>
+        /// Arbitrary key-value pairs from YAML front-matter.
+        /// Keys are user-defined field names, values can be string, number, boolean, or structured data.
+        /// No required keys, no filtering - entirely user-defined.
+        /// Template accesses via frontmatter.key or frontmatter["key"] syntax.
+        /// </summary>
+        public Dictionary<string, object> Frontmatter { get; set; } = new Dictionary<string, object>();
+
+        /// <summary>
+        /// Original markdown filename without path or extension.
+        /// Useful for debugging, display, or conditional logic.
+        /// Null if not available or not provided.
+        /// </summary>
+        public string? Filename { get; set; }
+
+        /// <summary>
+        /// File creation timestamp from filesystem metadata.
+        /// May not be available on all platforms.
+        /// Null if unavailable.
+        /// </summary>
+        public DateTime? Created { get; set; }
+
+        /// <summary>
+        /// File modification timestamp from filesystem metadata.
+        /// More reliable than creation time.
+        /// Null if unavailable.
+        /// </summary>
+        public DateTime? Modified { get; set; }
+    }
+}

src/Blog/PostPage/PostPageGenerator.Markdown.cs

@@ -0,0 +1,113 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Markdig;
+using OwlCore.Storage;
+using YamlDotNet.Serialization;
+
+namespace WindowsAppCommunity.Blog.PostPage
+{
+    /// <summary>
+    /// Markdown processing operations for PostPageGenerator.
+    /// Handles front-matter extraction, markdown transformation, and YAML parsing.
+    /// </summary>
+    public partial class PostPageGenerator
+    {
+        /// <summary>
+        /// Extract YAML front-matter block from markdown file.
+        /// Front-matter is delimited by "---" at start and end.
+        /// Handles files without front-matter (returns empty string for frontmatter).
+        /// </summary>
+        /// <param name="file">Markdown file to parse</param>
+        /// <returns>Tuple of (frontmatter YAML string, content markdown string)</returns>
+        private async Task<(string frontmatter, string content)> ParseMarkdownAsync(IFile file)
+        {
+            var text = await file.ReadTextAsync();
+            
+            // Gap #12 resolution: Check for front-matter delimiters
+            if (!text.StartsWith("---"))
+            {
+                // No front-matter present
+                return (string.Empty, text);
+            }
+
+            // Find the closing delimiter
+            var lines = text.Split(new[] { '\r', '\n' }, StringSplitOptions.None);
+            var closingDelimiterIndex = -1;
+            
+            for (int i = 1; i < lines.Length; i++)
+            {
+                if (lines[i].Trim() == "---")
+                {
+                    closingDelimiterIndex = i;
+                    break;
+                }
+            }
+
+            if (closingDelimiterIndex == -1)
+            {
+                // No closing delimiter found - treat entire file as content
+                return (string.Empty, text);
+            }
+
+            // Extract front-matter (lines between delimiters)
+            var frontmatterLines = lines.Skip(1).Take(closingDelimiterIndex - 1);
+            var frontmatter = string.Join(Environment.NewLine, frontmatterLines);
+
+            // Extract content (everything after closing delimiter)
+            var contentLines = lines.Skip(closingDelimiterIndex + 1);
+            var content = string.Join(Environment.NewLine, contentLines);
+
+            return (frontmatter, content);
+        }
+
+        /// <summary>
+        /// Transform markdown content to HTML body using Markdig.
+        /// Returns HTML without wrapping elements - template controls structure.
+        /// Uses Advanced Extensions pipeline for full Markdown feature support.
+        /// </summary>
+        /// <param name="markdown">Markdown content string</param>
+        /// <returns>HTML body content</returns>
+        private string TransformMarkdownToHtml(string markdown)
+        {
+            // Gap #1 resolution: Use Markdig Advanced Extensions pipeline
+            var pipeline = new MarkdownPipelineBuilder()
+                .UseAdvancedExtensions()
+                .Build();
+
+            return Markdown.ToHtml(markdown, pipeline);
+        }
+
+        /// <summary>
+        /// Parse YAML front-matter string to arbitrary dictionary.
+        /// No schema enforcement - accepts any valid YAML structure.
+        /// Handles empty/missing front-matter gracefully.
+        /// </summary>
+        /// <param name="yaml">YAML string from front-matter</param>
+        /// <returns>Dictionary with arbitrary keys and values</returns>
+        private Dictionary<string, object> ParseFrontmatter(string yaml)
+        {
+            // Handle empty front-matter
+            if (string.IsNullOrWhiteSpace(yaml))
+            {
+                return new Dictionary<string, object>();
+            }
+
+            // Gap #2 resolution: YamlDotNet with error handling
+            try
+            {
+                var deserializer = new DeserializerBuilder()
+                    .Build();
+
+                var result = deserializer.Deserialize<Dictionary<string, object>>(yaml);
+                return result ?? new Dictionary<string, object>();
+            }
+            catch (YamlDotNet.Core.YamlException ex)
+            {
+                // Gap #4 resolution: Exception-based error handling (no try-catch in caller)
+                throw new InvalidOperationException($"Failed to parse YAML front-matter: {ex.Message}", ex);
+            }
+        }
+    }
+}

src/Blog/PostPage/PostPageGenerator.Template.cs

@@ -0,0 +1,119 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using OwlCore.Storage;
+using Scriban;
+
+namespace WindowsAppCommunity.Blog.PostPage
+{
+    /// <summary>
+    /// Template processing operations for PostPageGenerator.
+    /// Handles template resolution, asset copying, and Scriban rendering.
+    /// </summary>
+    public partial class PostPageGenerator
+    {
+        /// <summary>
+        /// Resolve template file from IStorable source.
+        /// Handles both IFile (single template) and IFolder (template + assets).
+        /// Uses convention-based lookup ("template.html") when source is folder.
+        /// </summary>
+        /// <param name="templateSource">Template as IFile or IFolder</param>
+        /// <param name="templateFileName">File name when source is IFolder (defaults to "template.html")</param>
+        /// <returns>Resolved template IFile</returns>
+        private async Task<IFile> ResolveTemplateFileAsync(
+            IStorable templateSource,
+            string? templateFileName)
+        {
+            // Gap #8 resolution: Type detection using pattern matching
+            if (templateSource is IFile file)
+            {
+                // Direct file reference
+                return file;
+            }
+
+            if (templateSource is IFolder folder)
+            {
+                // Gap #3 resolution: Convention-based template file lookup
+                var fileName = templateFileName ?? "template.html";
+                var templateFile = await folder.GetFirstByNameAsync(fileName);
+
+                if (templateFile is not IFile resolvedFile)
+                {
+                    throw new FileNotFoundException(
+                        $"Template file '{fileName}' not found in folder '{folder.Name}'.");
+                }
+
+                return resolvedFile;
+            }
+
+            throw new ArgumentException(
+                $"Template source must be IFile or IFolder, got: {templateSource.GetType().Name}",
+                nameof(templateSource));
+        }
+
+        /// <summary>
+        /// Recursively copy all assets from template folder to output folder.
+        /// Excludes template file itself to avoid duplication.
+        /// Preserves folder structure using OwlCore.Storage recursive operations.
+        /// </summary>
+        /// <param name="templateFolder">Source template folder</param>
+        /// <param name="outputFolder">Destination output folder</param>
+        /// <param name="templateFile">Template file to exclude from copy</param>
+        private async Task CopyTemplateAssetsAsync(
+            IFolder templateFolder,
+            IFolder outputFolder,
+            IFile templateFile)
+        {
+            // Gap #11 resolution: Use DepthFirstRecursiveFolder for recursive traversal
+            var recursiveFolder = new DepthFirstRecursiveFolder(templateFolder);
+
+            // Gap #7 resolution: Filter files and exclude template file by ID comparison
+            await foreach (var item in recursiveFolder.GetItemsAsync(StorableType.File))
+            {
+                if (item is not IFile file)
+                    continue;
+
+                // Exclude the template file itself
+                if (file.Id == templateFile.Id)
+                    continue;
+
+                // Copy asset to output folder (overwrite silently per Gap #6)
+                if (outputFolder is IModifiableFolder modifiableOutput)
+                {
+                    await modifiableOutput.CreateCopyOfAsync(file, overwrite: true);
+                }
+            }
+        }
+
+        /// <summary>
+        /// Render Scriban template with data model to produce final HTML.
+        /// Template generates all HTML including meta tags from model.frontmatter.
+        /// Flow boundary: Generator provides data model, template generates HTML.
+        /// </summary>
+        /// <param name="templateFile">Scriban template file</param>
+        /// <param name="model">PostPageDataModel with body, frontmatter, metadata</param>
+        /// <returns>Rendered HTML string</returns>
+        private async Task<string> RenderTemplateAsync(
+            IFile templateFile,
+            PostPageDataModel model)
+        {
+            // Read template content
+            var templateContent = await templateFile.ReadTextAsync();
+
+            // Parse Scriban template
+            var template = Template.Parse(templateContent);
+
+            if (template.HasErrors)
+            {
+                var errors = string.Join(Environment.NewLine, template.Messages);
+                throw new InvalidOperationException($"Template parsing failed:{Environment.NewLine}{errors}");
+            }
+
+            // Render template with model
+            var html = template.Render(model);
+
+            return html;
+        }
+    }
+}