LICENSE

@@ -0,0 +1,438 @@
+Attribution-NonCommercial-ShareAlike 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+    wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public:
+    wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International
+Public License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-NonCommercial-ShareAlike 4.0 International Public License
+("Public License"). To the extent this Public License may be
+interpreted as a contract, You are granted the Licensed Rights in
+consideration of Your acceptance of these terms and conditions, and the
+Licensor grants You such rights in consideration of benefits the
+Licensor receives from making the Licensed Material available under
+these terms and conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. BY-NC-SA Compatible License means a license listed at
+     creativecommons.org/compatiblelicenses, approved by Creative
+     Commons as essentially the equivalent of this Public License.
+
+  d. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  e. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  f. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  g. License Elements means the license attributes listed in the name
+     of a Creative Commons Public License. The License Elements of this
+     Public License are Attribution, NonCommercial, and ShareAlike.
+
+  h. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  i. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  j. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  k. NonCommercial means not primarily intended for or directed towards
+     commercial advantage or monetary compensation. For purposes of
+     this Public License, the exchange of the Licensed Material for
+     other material subject to Copyright and Similar Rights by digital
+     file-sharing or similar means is NonCommercial provided there is
+     no payment of monetary compensation in connection with the
+     exchange.
+
+  l. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  m. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  n. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part, for NonCommercial purposes only; and
+
+            b. produce, reproduce, and Share Adapted Material for
+               NonCommercial purposes only.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. Additional offer from the Licensor -- Adapted Material.
+               Every recipient of Adapted Material from You
+               automatically receives an offer from the Licensor to
+               exercise the Licensed Rights in the Adapted Material
+               under the conditions of the Adapter's License You apply.
+
+            c. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties, including when
+          the Licensed Material is used other than for NonCommercial
+          purposes.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+  b. ShareAlike.
+
+     In addition to the conditions in Section 3(a), if You Share
+     Adapted Material You produce, the following conditions also apply.
+
+       1. The Adapter's License You apply must be a Creative Commons
+          license with the same License Elements, this version or
+          later, or a BY-NC-SA Compatible License.
+
+       2. You must include the text of, or the URI or hyperlink to, the
+          Adapter's License You apply. You may satisfy this condition
+          in any reasonable manner based on the medium, means, and
+          context in which You Share Adapted Material.
+
+       3. You may not offer or impose any additional or different terms
+          or conditions on, or apply any Effective Technological
+          Measures to, Adapted Material that restrict exercise of the
+          rights granted under the Adapter's License You apply.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database for NonCommercial purposes
+     only;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material,
+     including for purposes of Section 3(b); and
+
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.
+

README.md

@@ -0,0 +1,9 @@
+# YaeBlog
+
+Ricardo Ren 的个人主页和博客仓库。
+
+主页地址：[rrricardo.top](https://rrricardo.top)
+
+博客地址：[rrricardo.top/blog/](https://rrricardo.top/blog/)
+
+欢迎各位来玩~ 未来也会添加更多有趣的功能~

YaeBlog.Core/Abstractions/IEssayContentService.cs

@@ -9,5 +9,14 @@ public interface IEssayContentService
 
     public IReadOnlyDictionary<EssayTag, List<BlogEssay>> Tags { get; }
 
-    public bool SearchByUrlEncodedTag(string tag,[NotNullWhen(true)] out List<BlogEssay>? result);
+    public IReadOnlyDictionary<string, BlogHeadline> Headlines { get; }
+
+    public bool TryAddHeadline(string filename, BlogHeadline headline);
+    public bool SearchByUrlEncodedTag(string tag, [NotNullWhen(true)] out List<BlogEssay>? result);
+
+    public bool TryAdd(BlogEssay essay);
+
+    public void RefreshTags();
+
+    public void Clear();
 }

YaeBlog.Core/Abstractions/IEssayScanService.cs

@@ -0,0 +1,10 @@
+using YaeBlog.Core.Models;
+
+namespace YaeBlog.Core.Abstractions;
+
+public interface IEssayScanService
+{
+    public Task<BlogContents> ScanContents();
+
+    public Task SaveBlogContent(BlogContent content, bool isDraft = true);
+}

YaeBlog.Core/Abstractions/ITableOfContentService.cs

@@ -1,8 +0,0 @@
-using YaeBlog.Core.Models;
-
-namespace YaeBlog.Core.Abstractions;
-
-public interface ITableOfContentService
-{
-    public IReadOnlyDictionary<string, BlogHeadline> Headlines { get; }
-}

YaeBlog.Core/Extensions/ServiceCollectionExtensions.cs

@@ -20,12 +20,14 @@ public static class ServiceCollectionExtensions
 
     public static IServiceCollection AddYamlParser(this IServiceCollection collection)
     {
-        DeserializerBuilder builder = new();
+        DeserializerBuilder deserializerBuilder = new();
+        deserializerBuilder.WithNamingConvention(CamelCaseNamingConvention.Instance);
+        deserializerBuilder.IgnoreUnmatchedProperties();
+        collection.AddSingleton(deserializerBuilder.Build());
 
-        builder.WithNamingConvention(CamelCaseNamingConvention.Instance);
+        SerializerBuilder serializerBuilder = new();
-        builder.IgnoreUnmatchedProperties();
+        serializerBuilder.WithNamingConvention(CamelCaseNamingConvention.Instance);
-
+        collection.AddSingleton(serializerBuilder.Build());
-        collection.AddSingleton<IDeserializer>(_ => builder.Build());
 
         return collection;
     }

YaeBlog.Core/Extensions/WebApplicationBuilderExtensions.cs

@@ -20,14 +20,9 @@ public static class WebApplicationBuilderExtensions
         builder.Services.AddMarkdig();
         builder.Services.AddYamlParser();
         builder.Services.AddSingleton<IConfiguration>(_ => Configuration.Default);
-        builder.Services.AddSingleton<EssayScanService>();
+        builder.Services.AddSingleton<IEssayScanService, EssayScanService>();
         builder.Services.AddSingleton<RendererService>();
-        builder.Services.AddSingleton<EssayContentService>();
+        builder.Services.AddSingleton<IEssayContentService, EssayContentService>();
-        builder.Services.AddSingleton<IEssayContentService, EssayContentService>(provider =>
-            provider.GetRequiredService<EssayContentService>());
-        builder.Services.AddSingleton<TableOfContentService>();
-        builder.Services.AddSingleton<ITableOfContentService, TableOfContentService>(provider =>
-            provider.GetRequiredService<TableOfContentService>());
         builder.Services.AddTransient<ImagePostRenderProcessor>();
         builder.Services.AddTransient<CodeBlockPostRenderProcessor>();
         builder.Services.AddTransient<TablePostRenderProcessor>();
@@ -35,8 +30,21 @@ public static class WebApplicationBuilderExtensions
         builder.Services.AddTransient<BlogOptions>(provider =>
             provider.GetRequiredService<IOptions<BlogOptions>>().Value);
 
+        return builder;
+    }
+
+    public static WebApplicationBuilder AddServer(this WebApplicationBuilder builder)
+    {
         builder.Services.AddHostedService<BlogHostedService>();
 
         return builder;
     }
+
+    public static WebApplicationBuilder AddWatcher(this WebApplicationBuilder builder)
+    {
+        builder.Services.AddTransient<BlogChangeWatcher>();
+        builder.Services.AddHostedService<BlogHotReloadService>();
+
+        return builder;
+    }
 }

YaeBlog.Core/Models/BlogContent.cs

@@ -4,5 +4,7 @@ public class BlogContent
 {
     public required string FileName { get; init; }
 
+    public required MarkdownMetadata Metadata { get; init; }
+
     public required string FileContent { get; set; }
 }

YaeBlog.Core/Models/BlogContents.cs

@@ -0,0 +1,10 @@
+using System.Collections.Concurrent;
+
+namespace YaeBlog.Core.Models;
+
+public sealed class BlogContents(ConcurrentBag<BlogContent> drafts, ConcurrentBag<BlogContent> posts)
+{
+    public ConcurrentBag<BlogContent> Drafts { get; } = drafts;
+
+    public ConcurrentBag<BlogContent> Posts { get; } = posts;
+}

YaeBlog.Core/Processors/HeadlinePostRenderProcessor.cs

@@ -1,14 +1,15 @@
 using AngleSharp;
 using AngleSharp.Dom;
+using Microsoft.Extensions.Logging;
 using YaeBlog.Core.Abstractions;
 using YaeBlog.Core.Models;
-using YaeBlog.Core.Services;
 
 namespace YaeBlog.Core.Processors;
 
 public class HeadlinePostRenderProcessor(
     IConfiguration angleConfiguration,
-    TableOfContentService tableOfContentService) : IPostRenderProcessor
+    IEssayContentService essayContentService,
+    ILogger<HeadlinePostRenderProcessor> logger) : IPostRenderProcessor
 {
     public async Task<BlogEssay> ProcessAsync(BlogEssay essay)
     {
@@ -62,7 +63,10 @@ public class HeadlinePostRenderProcessor(
         FindParentHeadline(topHeadline, level2List).Children.AddRange(level3List);
         topHeadline.Children.AddRange(level2List);
 
-        tableOfContentService.AddHeadline(essay.FileName, topHeadline);
+        if (!essayContentService.TryAddHeadline(essay.FileName, topHeadline))
+        {
+            logger.LogWarning("Failed to add headline of {}.", essay.FileName);
+        }
 
         return essay.WithNewHtmlContent(document.DocumentElement.OuterHtml);
     }

YaeBlog.Core/Processors/ImagePostRenderProcessor.cs

@@ -3,6 +3,7 @@ using AngleSharp.Dom;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using YaeBlog.Core.Abstractions;
+using YaeBlog.Core.Exceptions;
 using YaeBlog.Core.Models;
 
 namespace YaeBlog.Core.Processors;
@@ -47,12 +48,12 @@ public class ImagePostRenderProcessor(ILogger<ImagePostRenderProcessor> logger,
             filename = Path.Combine(essayFilename, filename);
         }
 
-        filename = Path.Combine(_options.Root, filename);
+        filename = Path.Combine(_options.Root, "posts", filename);
 
         if (!Path.Exists(filename))
         {
             logger.LogError("Failed to found image: {}.", filename);
-            throw new InvalidOperationException();
+            throw new BlogFileException($"Image {filename} doesn't exist.");
         }
 
         string imageLink = "api/files/" + filename;

YaeBlog.Core/README.md

@@ -1,5 +0,0 @@
-# YaeBlog.Core
-
-A blog generation totally based on Blazor.
-
-You can using this to create your blog all in .NET stack!

YaeBlog.Core/Services/BlogChangeWatcher.cs

@@ -0,0 +1,61 @@
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using YaeBlog.Core.Models;
+
+namespace YaeBlog.Core.Services;
+
+public sealed class BlogChangeWatcher : IDisposable
+{
+    private readonly FileSystemWatcher _fileSystemWatcher;
+    private readonly ILogger<BlogChangeWatcher> _logger;
+
+    public BlogChangeWatcher(IOptions<BlogOptions> options, ILogger<BlogChangeWatcher> logger)
+    {
+        _logger = logger;
+        _fileSystemWatcher = new FileSystemWatcher(Path.Combine(Environment.CurrentDirectory, options.Value.Root));
+
+        _fileSystemWatcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName |
+                                          NotifyFilters.DirectoryName | NotifyFilters.Size;
+        _fileSystemWatcher.IncludeSubdirectories = true;
+        _fileSystemWatcher.EnableRaisingEvents = true;
+    }
+
+    public async Task<string?> WaitForChange(CancellationToken cancellationToken = default)
+    {
+        TaskCompletionSource<string?> tcs = new();
+        cancellationToken.Register(() => tcs.TrySetResult(null));
+
+        _logger.LogDebug("Register file change handle.");
+        _fileSystemWatcher.Changed += FileChangedCallback;
+        _fileSystemWatcher.Created += FileChangedCallback;
+        _fileSystemWatcher.Deleted += FileChangedCallback;
+        _fileSystemWatcher.Renamed += FileChangedCallback;
+
+        string? result;
+        try
+        {
+            result = await tcs.Task;
+        }
+        finally
+        {
+            _logger.LogDebug("Unregister file change handle.");
+            _fileSystemWatcher.Changed -= FileChangedCallback;
+            _fileSystemWatcher.Created -= FileChangedCallback;
+            _fileSystemWatcher.Deleted -= FileChangedCallback;
+            _fileSystemWatcher.Renamed -= FileChangedCallback;
+        }
+
+        return result;
+
+        void FileChangedCallback(object _, FileSystemEventArgs e)
+        {
+            _logger.LogDebug("File {} change detected.", e.Name);
+            tcs.TrySetResult(e.Name);
+        }
+    }
+
+    public void Dispose()
+    {
+        _fileSystemWatcher.Dispose();
+    }
+}

YaeBlog.Core/Services/BlogHotReloadService.cs

@@ -0,0 +1,35 @@
+using Microsoft.Extensions.Hosting;
+using Microsoft.Extensions.Logging;
+using YaeBlog.Core.Abstractions;
+
+namespace YaeBlog.Core.Services;
+
+public sealed class BlogHotReloadService(
+    RendererService rendererService,
+    IEssayContentService essayContentService,
+    BlogChangeWatcher watcher,
+    ILogger<BlogHotReloadService> logger) : BackgroundService
+{
+    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
+    {
+        logger.LogInformation("BlogHotReloadService is starting.");
+
+        await rendererService.RenderAsync();
+
+        while (!stoppingToken.IsCancellationRequested)
+        {
+            logger.LogDebug("Watching file changes...");
+            string? changFile = await watcher.WaitForChange(stoppingToken);
+
+            if (changFile is null)
+            {
+                logger.LogInformation("BlogHotReloadService is stopping.");
+                break;
+            }
+
+            logger.LogInformation("{} changed, re-rendering.", changFile);
+            essayContentService.Clear();
+            await rendererService.RenderAsync();
+        }
+    }
+}

YaeBlog.Core/Services/EssayContentService.cs

@@ -11,12 +11,18 @@ public class EssayContentService : IEssayContentService
 
     private readonly Dictionary<EssayTag, List<BlogEssay>> _tags = [];
 
+    private readonly ConcurrentDictionary<string, BlogHeadline> _headlines = new();
+
     public bool TryAdd(BlogEssay essay) => _essays.TryAdd(essay.FileName, essay);
 
+    public bool TryAddHeadline(string filename, BlogHeadline headline) => _headlines.TryAdd(filename, headline);
+
     public IReadOnlyDictionary<string, BlogEssay> Essays => _essays;
 
     public IReadOnlyDictionary<EssayTag, List<BlogEssay>> Tags => _tags;
 
+    public IReadOnlyDictionary<string, BlogHeadline> Headlines => _headlines;
+
     public void RefreshTags()
     {
          _tags.Clear();
@@ -45,4 +51,11 @@ public class EssayContentService : IEssayContentService
 
         return result is not null;
     }
+
+    public void Clear()
+    {
+        _essays.Clear();
+        _tags.Clear();
+        _headlines.Clear();
+    }
 }

YaeBlog.Core/Services/EssayScanService.cs

@@ -1,20 +1,104 @@
 using System.Collections.Concurrent;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
+using YaeBlog.Core.Abstractions;
 using YaeBlog.Core.Exceptions;
 using YaeBlog.Core.Models;
+using YamlDotNet.Core;
+using YamlDotNet.Serialization;
 
 namespace YaeBlog.Core.Services;
 
 public class EssayScanService(
+    ISerializer yamlSerializer,
+    IDeserializer yamlDeserializer,
     IOptions<BlogOptions> blogOptions,
-    ILogger<EssayContentService> logger)
+    ILogger<EssayScanService> logger) : IEssayScanService
 {
     private readonly BlogOptions _blogOptions = blogOptions.Value;
 
-    public async Task<List<BlogContent>> ScanAsync()
+    public async Task<BlogContents> ScanContents()
     {
-        string root = Path.Combine(Environment.CurrentDirectory, _blogOptions.Root);
+        ValidateDirectory(_blogOptions.Root, out DirectoryInfo drafts, out DirectoryInfo posts);
+
+        return new BlogContents(
+            await ScanContentsInternal(drafts),
+            await ScanContentsInternal(posts));
+    }
+
+    public async Task SaveBlogContent(BlogContent content, bool isDraft = true)
+    {
+        ValidateDirectory(_blogOptions.Root, out DirectoryInfo drafts, out DirectoryInfo posts);
+
+        FileInfo targetFile = isDraft
+            ? new FileInfo(Path.Combine(drafts.FullName, content.FileName + ".md"))
+            : new FileInfo(Path.Combine(posts.FullName, content.FileName + ".md"));
+
+        if (targetFile.Exists)
+        {
+            logger.LogWarning("Blog {} exists, overriding.", targetFile.Name);
+        }
+
+        await using StreamWriter writer = targetFile.CreateText();
+
+        await writer.WriteAsync("---\n");
+        await writer.WriteAsync(yamlSerializer.Serialize(content.Metadata));
+        await writer.WriteAsync("---\n");
+        await writer.WriteAsync("<!--more-->\n");
+    }
+
+    private async Task<ConcurrentBag<BlogContent>> ScanContentsInternal(DirectoryInfo directory)
+    {
+        IEnumerable<FileInfo> markdownFiles = from file in directory.EnumerateFiles()
+            where file.Extension == ".md"
+            select file;
+
+        ConcurrentBag<(string, string)> fileContents = [];
+
+        await Parallel.ForEachAsync(markdownFiles, async (file, token) =>
+        {
+            using StreamReader reader = file.OpenText();
+            fileContents.Add((file.Name, await reader.ReadToEndAsync(token)));
+        });
+
+        ConcurrentBag<BlogContent> contents = [];
+
+        await Task.Run(() =>
+        {
+            foreach ((string filename, string content) in fileContents)
+            {
+                int endPos = content.IndexOf("---", 4, StringComparison.Ordinal);
+                if (!content.StartsWith("---") || endPos is -1 or 0)
+                {
+                    logger.LogWarning("Failed to parse metadata from {}, skipped.", filename);
+                    return;
+                }
+
+                string metadataString = content[4..endPos];
+
+                try
+                {
+                    MarkdownMetadata metadata = yamlDeserializer.Deserialize<MarkdownMetadata>(metadataString);
+                    logger.LogDebug("Scan metadata title: '{}' for {}.", metadata.Title, filename);
+
+                    contents.Add(new BlogContent
+                    {
+                        FileName = filename[..^3], Metadata = metadata, FileContent = content[(endPos + 3)..]
+                    });
+                }
+                catch (YamlException e)
+                {
+                    logger.LogWarning("Failed to parser metadata from {} due to {}, skipping", filename, e);
+                }
+            }
+        });
+
+        return contents;
+    }
+
+    private void ValidateDirectory(string root, out DirectoryInfo drafts, out DirectoryInfo posts)
+    {
+        root = Path.Combine(Environment.CurrentDirectory, root);
         DirectoryInfo rootDirectory = new(root);
 
         if (!rootDirectory.Exists)
@@ -22,36 +106,17 @@ public class EssayScanService(
             throw new BlogFileException($"'{root}' is not a directory.");
         }
 
-        List<FileInfo> markdownFiles = [];
+        if (rootDirectory.EnumerateDirectories().All(dir => dir.Name != "drafts"))
-
-        await Task.Run(() =>
         {
-            foreach (FileInfo fileInfo in rootDirectory.EnumerateFiles())
+            throw new BlogFileException($"'{root}/drafts' not exists.");
-            {
-                if (fileInfo.Extension != ".md")
-                {
-                    continue;
         }
 
-                logger.LogDebug("Scan markdown file: {}.", fileInfo.Name);
+        if (rootDirectory.EnumerateDirectories().All(dir => dir.Name != "posts"))
-                markdownFiles.Add(fileInfo);
+        {
+            throw new BlogFileException($"'{root}/posts' not exists.");
         }
-        });
 
-        ConcurrentBag<BlogContent> contents = [];
+        drafts = new DirectoryInfo(Path.Combine(root, "drafts"));
-
+        posts = new DirectoryInfo(Path.Combine(root, "posts"));
-        await Parallel.ForEachAsync(markdownFiles, async (info, token) =>
-        {
-            StreamReader reader = new(info.OpenRead());
-
-            BlogContent content = new()
-            {
-                FileName = info.Name.Split('.')[0], FileContent = await reader.ReadToEndAsync(token)
-            };
-
-            contents.Add(content);
-        });
-
-        return contents.ToList();
     }
 }

YaeBlog.Core/Services/RendererService.cs

@@ -7,17 +7,14 @@ using Microsoft.Extensions.Logging;
 using YaeBlog.Core.Abstractions;
 using YaeBlog.Core.Exceptions;
 using YaeBlog.Core.Models;
-using YamlDotNet.Core;
-using YamlDotNet.Serialization;
 
 namespace YaeBlog.Core.Services;
 
 public partial class RendererService(
     ILogger<RendererService> logger,
-    EssayScanService essayScanService,
+    IEssayScanService essayScanService,
     MarkdownPipeline markdownPipeline,
-    IDeserializer yamlDeserializer,
+    IEssayContentService essayContentService)
-    EssayContentService essayContentService)
 {
     private readonly Stopwatch _stopwatch = new();
 
@@ -30,30 +27,30 @@ public partial class RendererService(
         _stopwatch.Start();
         logger.LogInformation("Render essays start.");
 
-        List<BlogContent> contents = await essayScanService.ScanAsync();
+        BlogContents contents = await essayScanService.ScanContents();
-        IEnumerable<BlogContent> preProcessedContents = await PreProcess(contents);
+        List<BlogContent> posts = contents.Posts.ToList();
+        IEnumerable<BlogContent> preProcessedContents = await PreProcess(posts);
 
         List<BlogEssay> essays = [];
         await Task.Run(() =>
         {
             foreach (BlogContent content in preProcessedContents)
             {
-                MarkdownMetadata? metadata = TryParseMetadata(content);
                 uint wordCount = GetWordCount(content);
                 BlogEssay essay = new()
                 {
-                    Title = metadata?.Title ?? content.FileName,
+                    Title = content.Metadata.Title ?? content.FileName,
                     FileName = content.FileName,
                     Description = GetDescription(content),
                     WordCount = wordCount,
                     ReadTime = CalculateReadTime(wordCount),
-                    PublishTime = metadata?.Date ?? DateTime.Now,
+                    PublishTime = content.Metadata.Date ?? DateTime.Now,
                     HtmlContent = content.FileContent
                 };
 
-                if (metadata?.Tags is not null)
+                if (content.Metadata.Tags is not null)
                 {
-                    essay.Tags.AddRange(metadata.Tags);
+                    essay.Tags.AddRange(content.Metadata.Tags);
                 }
 
                 essays.Add(essay);
@@ -138,45 +135,6 @@ public partial class RendererService(
         });
     }
 
-    private MarkdownMetadata? TryParseMetadata(BlogContent content)
-    {
-        string fileContent = content.FileContent.Trim();
-
-        if (!fileContent.StartsWith("---"))
-        {
-            return null;
-        }
-
-        // 移除起始的---
-        fileContent = fileContent[3..];
-
-        int lastPos = fileContent.IndexOf("---", StringComparison.Ordinal);
-        if (lastPos is -1 or 0)
-        {
-            return null;
-        }
-
-        string yamlContent = fileContent[..lastPos];
-        // 返回去掉元数据之后的文本
-        lastPos += 3;
-        content.FileContent = fileContent[lastPos..];
-
-        try
-        {
-            MarkdownMetadata metadata =
-                yamlDeserializer.Deserialize<MarkdownMetadata>(yamlContent);
-            logger.LogDebug("Title: {}, Publish Date: {}.",
-                metadata.Title, metadata.Date);
-
-            return metadata;
-        }
-        catch (YamlException e)
-        {
-            logger.LogWarning("Failed to parse '{}' metadata: {}", yamlContent, e);
-            return null;
-        }
-    }
-
     [GeneratedRegex(@"(?<!\\)[^\#\*_\-\+\`{}\[\]!~]+")]
     private static partial Regex DescriptionPattern();
 

YaeBlog.Core/Services/TableOfContentService.cs

@@ -1,20 +0,0 @@
-using System.Collections.Concurrent;
-using YaeBlog.Core.Abstractions;
-using YaeBlog.Core.Models;
-
-namespace YaeBlog.Core.Services;
-
-public class TableOfContentService : ITableOfContentService
-{
-    private readonly ConcurrentDictionary<string, BlogHeadline> _headlines = [];
-
-    public IReadOnlyDictionary<string, BlogHeadline> Headlines => _headlines;
-
-    public void AddHeadline(string filename, BlogHeadline headline)
-    {
-        if (!_headlines.TryAdd(filename, headline))
-        {
-            throw new InvalidOperationException();
-        }
-    }
-}

YaeBlog.Core/YaeBlog.Core.csproj

@@ -6,20 +6,6 @@
     <ImplicitUsings>enable</ImplicitUsings>
   </PropertyGroup>
 
-  <PropertyGroup>
-    <PackageId>YaeBlog.Core</PackageId>
-    <Version>0.1.0</Version>
-    <Authors>Ricardo Ren</Authors>
-    <Company>Ricardo Ren</Company>
-    <PackageLicenseExpression>MIT</PackageLicenseExpression>
-    <PackageReadmeFile>README.md</PackageReadmeFile>
-  </PropertyGroup>
-
-
-  <ItemGroup>
-    <SupportedPlatform Include="browser" />
-  </ItemGroup>
-
   <ItemGroup>
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
   </ItemGroup>
@@ -32,12 +18,6 @@
     <PackageReference Include="YamlDotNet" Version="13.7.1" />
   </ItemGroup>
 
-  <ItemGroup>
-    <None Include="../.gitignore" />
-    <None Include="../.editorconfig" />
-    <None Include="./README.md" Pack="true" PackagePath="/"/>
-  </ItemGroup>
-
   <ItemGroup>
     <Folder Include="wwwroot\" />
   </ItemGroup>

YaeBlog.sln

@@ -14,6 +14,15 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "workflows", "workflows", "{
 		.gitea\workflows\build.yaml = .gitea\workflows\build.yaml
 	EndProjectSection
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{753B998C-1B9E-498F-B949-845CE86C4075}"
+	ProjectSection(SolutionItems) = preProject
+		.editorconfig = .editorconfig
+		.gitattributes = .gitattributes
+		.gitignore = .gitignore
+		README.md = README.md
+		LICENSE = LICENSE
+	EndProjectSection
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU

YaeBlog/Commands/Binders/BlogOptionsBinder.cs

@@ -0,0 +1,36 @@
+using System.CommandLine.Binding;
+using System.Text.Json;
+using Microsoft.Extensions.Options;
+using YaeBlog.Core.Models;
+
+namespace YaeBlog.Commands.Binders;
+
+public sealed class BlogOptionsBinder : BinderBase<IOptions<BlogOptions>>
+{
+    protected override IOptions<BlogOptions> GetBoundValue(BindingContext bindingContext)
+    {
+        bindingContext.AddService<IOptions<BlogOptions>>(_ =>
+        {
+            FileInfo settings = new(Path.Combine(Environment.CurrentDirectory, "appsettings.json"));
+            if (!settings.Exists)
+            {
+                throw new InvalidOperationException("Failed to load YaeBlog configurations.");
+            }
+
+            using StreamReader reader = settings.OpenText();
+            using JsonDocument document = JsonDocument.Parse(reader.ReadToEnd());
+            JsonElement root = document.RootElement;
+            JsonElement optionSection = root.GetProperty(BlogOptions.OptionName);
+
+            BlogOptions? result = optionSection.Deserialize<BlogOptions>();
+            if (result is null)
+            {
+                throw new InvalidOperationException("Failed to load YaeBlog configuration in appsettings.json.");
+            }
+
+            return new OptionsWrapper<BlogOptions>(result);
+        });
+
+        return bindingContext.GetRequiredService<IOptions<BlogOptions>>();
+    }
+}

YaeBlog/Commands/Binders/EssayScanServiceBinder.cs

@@ -0,0 +1,32 @@
+using System.CommandLine.Binding;
+using Microsoft.Extensions.Options;
+using YaeBlog.Core.Abstractions;
+using YaeBlog.Core.Models;
+using YaeBlog.Core.Services;
+using YamlDotNet.Serialization;
+using YamlDotNet.Serialization.NamingConventions;
+
+namespace YaeBlog.Commands.Binders;
+
+public sealed class EssayScanServiceBinder : BinderBase<IEssayScanService>
+{
+    protected override IEssayScanService GetBoundValue(BindingContext bindingContext)
+    {
+        bindingContext.AddService<IEssayScanService>(provider =>
+        {
+            DeserializerBuilder deserializerBuilder = new();
+            deserializerBuilder.WithNamingConvention(CamelCaseNamingConvention.Instance);
+            deserializerBuilder.IgnoreUnmatchedProperties();
+
+            SerializerBuilder serializerBuilder = new();
+            serializerBuilder.WithNamingConvention(CamelCaseNamingConvention.Instance);
+
+            IOptions<BlogOptions> options = provider.GetRequiredService<IOptions<BlogOptions>>();
+            ILogger<EssayScanService> logger = provider.GetRequiredService<ILogger<EssayScanService>>();
+
+            return new EssayScanService(serializerBuilder.Build(), deserializerBuilder.Build(), options, logger);
+        });
+
+        return bindingContext.GetRequiredService<IEssayScanService>();
+    }
+}

YaeBlog/Commands/Binders/LoggerBinder.cs

@@ -0,0 +1,18 @@
+using System.CommandLine.Binding;
+
+namespace YaeBlog.Commands.Binders;
+
+public sealed class LoggerBinder<T> : BinderBase<ILogger<T>>
+{
+    protected override ILogger<T> GetBoundValue(BindingContext bindingContext)
+    {
+        bindingContext.AddService(_ => LoggerFactory.Create(builder => builder.AddConsole()));
+        bindingContext.AddService<ILogger<T>>(provider =>
+        {
+            ILoggerFactory factory = provider.GetRequiredService<ILoggerFactory>();
+            return factory.CreateLogger<T>();
+        });
+
+        return bindingContext.GetRequiredService<ILogger<T>>();
+    }
+}

YaeBlog/Commands/BlogOptionsBinder.cs

@@ -1,30 +0,0 @@
-using System.CommandLine.Binding;
-using System.Text.Json;
-using YaeBlog.Core.Models;
-
-namespace YaeBlog.Commands;
-
-public sealed class BlogOptionsBinder : BinderBase<BlogOptions>
-{
-    protected override BlogOptions GetBoundValue(BindingContext bindingContext)
-    {
-        FileInfo settings = new(Path.Combine(Environment.CurrentDirectory, "appsettings.json"));
-        if (!settings.Exists)
-        {
-            throw new InvalidOperationException("Failed to load YaeBlog configurations.");
-        }
-
-        using StreamReader reader = settings.OpenText();
-        using JsonDocument document = JsonDocument.Parse(reader.ReadToEnd());
-        JsonElement root = document.RootElement;
-        JsonElement optionSection = root.GetProperty(BlogOptions.OptionName);
-
-        BlogOptions? result = optionSection.Deserialize<BlogOptions>();
-        if (result is null)
-        {
-            throw new InvalidOperationException("Failed to load YaeBlog configuration in appsettings.json.");
-        }
-
-        return result;
-    }
-}

YaeBlog/Commands/CommandExtensions.cs

@@ -1,12 +1,15 @@
 using System.CommandLine;
+using YaeBlog.Commands.Binders;
 using YaeBlog.Components;
 using YaeBlog.Core.Extensions;
+using YaeBlog.Core.Models;
+using YaeBlog.Core.Services;
 
 namespace YaeBlog.Commands;
 
 public static class CommandExtensions
 {
-    public static Command AddServeCommand(this RootCommand rootCommand)
+    public static void AddServeCommand(this RootCommand rootCommand)
     {
         Command serveCommand = new("serve", "Start http server.");
         rootCommand.AddCommand(serveCommand);
@@ -20,6 +23,7 @@ public static class CommandExtensions
             builder.Services.AddControllers();
             builder.Services.AddBlazorBootstrap();
             builder.AddYaeBlog();
+            builder.AddServer();
 
             WebApplication application = builder.Build();
 
@@ -34,11 +38,40 @@ public static class CommandExtensions
             CancellationToken token = context.GetCancellationToken();
             await application.RunAsync(token);
         });
-
-        return rootCommand;
     }
 
-    public static Command AddNewCommand(this RootCommand rootCommand)
+    public static void AddWatchCommand(this RootCommand rootCommand)
+    {
+        Command command = new("watch", "Start a blog watcher that re-render when file changes.");
+        rootCommand.AddCommand(command);
+
+        command.SetHandler(async context =>
+        {
+            WebApplicationBuilder builder = WebApplication.CreateBuilder();
+
+            builder.Services.AddRazorComponents()
+                .AddInteractiveServerComponents();
+            builder.Services.AddControllers();
+            builder.Services.AddBlazorBootstrap();
+            builder.AddYaeBlog();
+            builder.AddWatcher();
+
+            WebApplication application = builder.Build();
+
+            application.UseStaticFiles();
+            application.UseAntiforgery();
+            application.UseYaeBlog();
+
+            application.MapRazorComponents<App>()
+                .AddInteractiveServerRenderMode();
+            application.MapControllers();
+
+            CancellationToken token = context.GetCancellationToken();
+            await application.RunAsync(token);
+        });
+    }
+
+    public static void AddNewCommand(this RootCommand rootCommand)
     {
         Command newCommand = new("new", "Create a new blog file and image directory.");
         rootCommand.AddCommand(newCommand);
@@ -46,45 +79,40 @@ public static class CommandExtensions
         Argument<string> filenameArgument = new(name: "blog name", description: "The created blog filename.");
         newCommand.AddArgument(filenameArgument);
 
-        newCommand.SetHandler(async (file, blogOptions) =>
+        newCommand.SetHandler(async (file, _, _, essayScanService) =>
             {
-            string fileWithExtension;
+                await essayScanService.SaveBlogContent(new BlogContent
-            if (file.EndsWith(".md"))
                 {
-                fileWithExtension = file;
+                    FileName = file,
-                file = fileWithExtension[..fileWithExtension.LastIndexOf('.')];
+                    FileContent = string.Empty,
-            }
+                    Metadata = new MarkdownMetadata { Title = file, Date = DateTime.Now }
-            else
+                });
-            {
-                fileWithExtension = file + ".md";
-            }
-
-            DirectoryInfo rootDir = new(Path.Combine(Environment.CurrentDirectory, blogOptions.Root));
-            if (!rootDir.Exists)
-            {
-                throw new InvalidOperationException($"Blog source directory '{blogOptions.Root} doesn't exist.");
-            }
-
-            if (rootDir.EnumerateFiles().Any(f => f.Name == fileWithExtension))
-            {
-                throw new InvalidOperationException($"Target blog '{file}' has been created!");
-            }
-
-            FileInfo newBlogFile = new(Path.Combine(rootDir.FullName, fileWithExtension));
-            await using StreamWriter newStream = newBlogFile.CreateText();
-
-            await newStream.WriteAsync($"""
-                                        ---
-                                        title: {file}
-                                        tags:
-                                        ---
-                                        <!--more-->
-                                        """);
 
                 Console.WriteLine($"Created new blog '{file}.");
-        }, filenameArgument, new BlogOptionsBinder());
+            }, filenameArgument, new BlogOptionsBinder(), new LoggerBinder<EssayScanService>(),
+            new EssayScanServiceBinder());
+    }
 
+    public static void AddListCommand(this RootCommand rootCommand)
+    {
+        Command command = new("list", "List all blogs");
+        rootCommand.Add(command);
 
-        return newCommand;
+        command.SetHandler(async (_, _, essyScanService) =>
+        {
+            BlogContents contents = await essyScanService.ScanContents();
+
+            Console.WriteLine($"All {contents.Posts.Count} Posts:");
+            foreach (BlogContent content in contents.Posts)
+            {
+                Console.WriteLine($" - {content.FileName}");
+            }
+
+            Console.WriteLine($"All {contents.Drafts.Count} Drafts:");
+            foreach (BlogContent content in contents.Drafts)
+            {
+                Console.WriteLine($" - {content.FileName}");
+            }
+        }, new BlogOptionsBinder(), new LoggerBinder<EssayScanService>(), new EssayScanServiceBinder());
     }
 }

YaeBlog/Pages/Essays.razor

@@ -4,7 +4,6 @@
 @using YaeBlog.Core.Models
 
 @inject IEssayContentService Contents
-@inject ITableOfContentService TableOfContent
 @inject NavigationManager NavigationInstance
 
 <PageTitle>
@@ -129,7 +128,7 @@
             NavigationInstance.NavigateTo("/NotFound");
         }
 
-        _headline = TableOfContent.Headlines[BlogKey];
+        _headline = Contents.Headlines[BlogKey];
     }
 
     private string GenerateSelectorUrl(string selectorId)

YaeBlog/Program.cs

@@ -5,5 +5,7 @@ RootCommand rootCommand = new("YaeBlog CLI");
 
 rootCommand.AddServeCommand();
 rootCommand.AddNewCommand();
+rootCommand.AddListCommand();
+rootCommand.AddWatchCommand();
 
 await rootCommand.InvokeAsync(args);

YaeBlog/source/drafts/test-essay.md

@@ -0,0 +1,6 @@
+---
+title: test-essay
+date: 2024-08-22T22:31:34.3177253+08:00
+tags: 
+---
+<!--more-->