# 检查hugo 是否正常安装
hugo version
# 创建目录`myblog`作为一个新的hugo站点
hugo new site myblog
cd myblog

# 本地初始化模块
hugo mod init myblog

[[imports]]
path = "github.com/jpanther/congo/v2"

hugo mod get -u

myblog/				# 项目根目录
├── archetypes/		# 内容模板目录
├── assets/			# 资源管道目录（编译时处理）
├── config/			# 配置文件目录
├── content/		# 内容目录（网站内容）
├── data/			# 数据文件目录
├── i18n/			# 国际化文件目录
├── layouts/		# 布局模板目录
├── static/			# 静态文件目录
├── themes/			# 主题目录（为空代表使用模块导入）
├── public/			# 构建输出目录
├── resources/		# 资源缓存目录（构建时生成）
└── go.mod			# Go模块文件

baseURL = "https://你的域名/"

languageCode = "zh-Hans"
defaultContentLanguage = "zh-Hans"
defaultContentLanguageInSubdir = false
timeZone = "Asia/Shanghai"

baseURL = "https://blog.huan666.de/"

languageCode = "zh-Hans"
defaultContentLanguage = "zh-Hans"
defaultContentLanguageInSubdir = false
timeZone = "Asia/Shanghai"

enableRobotsTXT = true
summaryLength = 0

[pagination]
pagerSize = 10

[frontmatter]
format = "yaml"
# 自动日期填充配置
# date: 文章发布时间 - 优先使用front matter中的date，否则使用文件修改时间
date = ["date", ":fileModTime"]
# lastmod: 最后修改时间 - 优先使用front matter设置，否则使用文件修改时间
lastmod = ["lastmod", ":fileModTime"]

[[cascade]]
isCJKLanguage = true
_target.lang = "zh-Hans"

[outputs]
home = ["HTML", "RSS", "JSON", "articles"]

[privacy]
[privacy.vimeo]
enableDNT = true
[privacy.x]
enableDNT = true
[privacy.youTube]
privacyEnhanced = true

[services]
[services.x]
disableInlineCSS = true

languageCode = "zh-Hans"
languageName = "简体中文"
weight = 1
contentDir = "content"

title = "焕昭君的博客"

[params.author]
name = "焕昭君"
image = "img/author.webp"
headline = "知行合一，日拱一卒"
bio = "知行合一，日拱一卒"
links = [
    { email = "mailto:[email protected]" },
    { github = "https://github.com/Huan-zhaojun" },
    { linuxdo = "https://linux.do/u/huan/summary" }
]

[[main]]
name = "文章"
pageRef = "posts"
weight = 10

[[main]]
name = "分类"
pageRef = "categories"
weight = 20

[[main]]
name = "标签"
pageRef = "tags"
weight = 30

[[main]]
name = "友链"
pageRef = "friends"
weight = 97

[[main]]
name = "关于"
pageRef = "about"
weight = 98

[[main]]
identifier = "search"
weight = 99
[main.params]
action = "search"

[[main]]
identifier = "locale"
weight = 100
[main.params]
action = "locale"

# -- Footer Menu --
# The footer menu is displayed at the bottom of the page, just before
# the copyright notice. Configure as per the main menu above.

[[footer]]
name = "随便逛逛"
pageRef = "random"
weight = 10
[footer.params]
icon = "lightbulb"

[[footer]]
name = "RSS订阅"
url = "/index.xml"
weight = 20
[footer.params]
icon = "rss"

[[footer]]
name = "站点地图"
url = "/sitemap.xml"
weight = 30
[footer.params]
icon = "globe"

content/
├── _index.md           	# 网站首页内容
├── about.md            	# 单独页面 (Page)
├── posts/              	# Section: 博客文章区
│   ├── _index.md       	# posts 列表页
│   ├── my-first-post.md
│   └── hugo-guide.md
├── projects/           	# Section: 项目展示区
│   ├── _index.md       	# projects 列表页
│   ├── project-1.md
│   └── awesome-app/    		# Page Bundle (页面捆绑)
│       ├── index.md    		# 页面内容
│       ├── screenshot.png  	# 页面资源
│       ├── cover.jpg        	# 封面图
│       ├── featured.png     	# 特色图
│       └── thumbnail.jpg    	# 缩略图
└── docs/              		# Section: 文档区
    ├── _index.md      		# docs 首页
    ├── getting-started.md
    └── advanced/      			# 子Section
        ├── _index.md  			# advanced 列表页
        └── performance.md

content/
├── posts/              # Branch Bundle目录
│   ├── _index.md       # 关键：使用 _index.md
│   ├── post-1.md
│   ├── post-2.md
│   └── images/
│       └── hero.jpg
└── about/              # 另一个Branch Bundle
    ├── _index.md
    ├── team.jpg
    └── company.pdf

hugo new content/_index.md			#编辑博客首页内容
hugo new content/posts/_index.md	#编辑文章列表内容
hugo new content content/posts/my-first-post.md   #编辑第一篇文章内容

+++
title = 'My First Post'
date = 2024-01-14T07:07:07+01:00
draft = true
+++

---
title: "{{ replace .File.ContentBaseName "-" " " | title }}"
#slug: ""
#description: "Meta标签 页面描述"
#summary: "文章预览 内容摘要"
date: {{ .Date }}
#lastmod: {{ .Date }}
draft: false
categories: []
tags: []
---

static/
├─ android-chrome-192x192.png
├─ android-chrome-512x512.png
├─ apple-touch-icon.png
├─ favicon-16x16.png
├─ favicon-32x32.png
├─ favicon.ico
└─ site.webmanifest

{{/* giscus 评论系统组件 */}}
<div class="giscus-comments">
  粘贴的 <script> 块
</div>

{{/* giscus 评论系统组件 - 增强版 */}}
{{/* 多语言自适应配置 */}}
{{- $giscusLang := "zh-CN" -}}
{{- if eq .Language.Lang "en" -}}
  {{- $giscusLang = "en" -}}
{{- end -}}

{{/* 路径标准化逻辑 - 统一多语言评论映射 */}}
{{- $commentTerm := .RelPermalink -}}
{{/* 统一去掉开头的斜杠 */}}
{{- $commentTerm = strings.Replace .RelPermalink "/" "" 1 -}}
{{- if eq .Language.Lang "en" -}}
  {{/* 对于英文页面，去掉 en/ 前缀来统一映射 */}}
  {{- $commentTerm = strings.Replace $commentTerm "en/" "" 1 -}}
{{- end -}}

<div class="giscus-comments">
  {{/* giscus评论组件 */}}
  <script src="https://giscus.app/client.js"
          data-repo="替换仓库名"
          data-repo-id="替换仓库ID"
          data-category="替换分类名"
          data-category-id="替换分类ID"
          data-mapping="specific"
          data-term="{{ $commentTerm }}"
          data-strict="1"
          data-reactions-enabled="1"
          data-emit-metadata="0"
          data-input-position="top"
          data-theme="preferred_color_scheme"
          data-lang="{{ $giscusLang }}"
          data-loading="lazy"
          crossorigin="anonymous"
          async>
  </script>

  {{/* giscus主题同步脚本 */}}
  <script>
    (function() {
      function sync() {
        const iframe = document.querySelector('iframe.giscus-frame');
        if (iframe) {
          iframe.contentWindow.postMessage({
            giscus: { setConfig: { theme: document.documentElement.classList.contains('dark') ? 'dark' : 'light' } }
          }, 'https://giscus.app');
        }
      }
      
      new MutationObserver(() => sync()).observe(document.documentElement, {
        attributes: true,
        attributeFilter: ['class']
      });
      
      window.addEventListener('message', (e) => {
        if (e.origin === 'https://giscus.app' && e.data?.giscus?.discussion) sync();
      });
    })();
  </script>
</div>

#!/usr/bin/env python3
# -*- coding: utf-8 -*-

# Windows控制台编码处理
import sys
if sys.platform == 'win32':
    import os
    os.system('chcp 65001 > nul')  # 设置控制台为UTF-8编码

__version__ = "1.6.0"

"""
Hugo博客Front Matter自动添加工具

功能：
- 自动为Markdown文件添加Front Matter
- 支持多文件、相对路径、绝对路径处理
- 智能备份和恢复机制
- 基于archetypes/default.md模板生成

使用方法：
python add_frontmatter.py file1.md file2.md
python add_frontmatter.py path/to/dir/
python add_frontmatter.py /absolute/path/to/file.md
"""

import os
import sys
import re
import shutil
import argparse
import time
from datetime import datetime
from pathlib import Path
from enum import Enum
# import chardet  # 移除依赖，使用内置方法

class LogLevel(Enum):
    """日志级别"""
    QUIET = 0    # 静默模式
    DEFAULT = 1  # 默认模式
    VERBOSE = 2  # 详细模式

class FrontMatterProcessor:
    def __init__(self, log_level=LogLevel.DEFAULT, preview_mode=False):
        self.log_level = log_level
        self.preview_mode = preview_mode
        self.script_dir = Path(__file__).parent
        self.backup_dir = self.script_dir / "add_frontmatter_backups"
        self.processed_count = 0
        self.skipped_count = 0
        self.error_count = 0
        self.created_backups = []
        
        # title生成模式：'as_is', 'formatted', 'fallback'
        self.title_generation_mode = 'fallback'
        
        # 结果收集
        self.processed_files = []  # 成功处理的文件
        self.skipped_files = []    # 跳过的文件
        self.error_files = []      # 错误文件
        self.preview_files = []    # 预览文件（预览模式专用）
        
        # 计时
        self.start_time = time.time()
        
        # 预览模式下不创建备份目录
        if not self.preview_mode:
            # 确保备份目录存在
            self.backup_dir.mkdir(exist_ok=True)
        
        # 智能查找项目结构
        self.project_root, self.archetype_path, self.content_path = self.find_project_structure()
        
        # 动态加载Front Matter模板
        self.template = self.load_template()
    
    def log(self, message, level=LogLevel.DEFAULT):
        """根据日志级别输出信息"""
        if self.log_level.value >= level.value:
            print(message)
    
    def log_verbose(self, message):
        """详细模式日志"""
        self.log(message, LogLevel.VERBOSE)
    
    def log_default(self, message):
        """默认模式日志"""
        self.log(message, LogLevel.DEFAULT)

    def find_project_structure(self):
        """智能查找项目根目录、archetypes和content路径"""
        self.log_verbose(f"[查找] 开始查找项目结构...")
        self.log_verbose(f"[查找] 程序位置: {self.script_dir}")
        self.log_verbose(f"[查找] 当前工作目录: {Path.cwd()}")
        
        def check_hugo_project(base_path):
            """检查指定路径是否为Hugo项目根目录"""
            archetype_path = base_path / "archetypes" / "default.md"
            content_path = base_path / "content"
            
            # 检查关键文件/目录是否存在
            has_archetype = archetype_path.exists()
            has_content = content_path.exists() and content_path.is_dir()
            has_config = any([
                (base_path / "config.toml").exists(),
                (base_path / "config.yaml").exists(),
                (base_path / "config.yml").exists(),
                (base_path / "hugo.toml").exists(),
                (base_path / "config" / "_default").exists()
            ])
            
            self.log_verbose(f"  [检查] {base_path}")
            self.log_verbose(f"    - archetypes/default.md: {'OK' if has_archetype else 'NO'}")
            self.log_verbose(f"    - content/ 目录: {'OK' if has_content else 'NO'}")  
            self.log_verbose(f"    - Hugo 配置文件: {'OK' if has_config else 'NO'}")
            
            # 至少需要有content目录，archetype可以使用默认模板
            if has_content and (has_archetype or has_config):
                return True, archetype_path, content_path
            return False, None, None
        
        # 查找策略：
        # 1. 从当前工作目录开始查找
        search_paths = [Path.cwd()]
        
        # 2. 从程序所在目录查找
        if self.script_dir != Path.cwd():
            search_paths.append(self.script_dir)
        
        # 3. 从程序所在目录向上层目录递归查找（最多5层）
        current_path = self.script_dir
        for i in range(5):  # 最多向上查找5层
            parent_path = current_path.parent
            if parent_path == current_path:  # 已经到达根目录
                break
            if parent_path not in search_paths:
                search_paths.append(parent_path)
            current_path = parent_path
        
        # 依次检查每个路径
        for search_path in search_paths:
            self.log_verbose(f"\n[搜索] 检查路径: {search_path}")
            is_hugo_project, archetype_path, content_path = check_hugo_project(search_path)
            
            if is_hugo_project:
                self.log_verbose(f"[成功] 找到Hugo项目根目录: {search_path}")
                return search_path, archetype_path, content_path
        
        # 如果都没找到，使用默认路径（向后兼容）
        self.log_verbose(f"\n[警告] 未找到标准Hugo项目结构")
        self.log_verbose(f"[警告] 使用默认路径配置")
        
        # 默认使用脚本目录的上级作为项目根目录
        default_root = self.script_dir.parent
        default_archetype = default_root / "archetypes" / "default.md"
        default_content = default_root / "content"
        
        self.log_verbose(f"[默认] 项目根目录: {default_root}")
        self.log_verbose(f"[默认] archetype路径: {default_archetype}")
        self.log_verbose(f"[默认] content路径: {default_content}")
        
        return default_root, default_archetype, default_content
    
    def group_files_by_directory(self, file_list):
        """按目录分组文件"""
        groups = {}
        for file_path in file_list:
            # 获取相对于项目根目录的路径
            try:
                relative_path = file_path.relative_to(self.project_root)
                dir_path = str(relative_path.parent)
                if dir_path == '.':
                    dir_path = ''
                else:
                    dir_path += '/'
            except ValueError:
                # 如果文件不在项目根目录下，使用绝对路径的父目录
                dir_path = str(file_path.parent) + '/'
            
            filename = file_path.name
            if dir_path not in groups:
                groups[dir_path] = []
            groups[dir_path].append(filename)
        return groups
    
    def format_grouped_files(self, groups, max_line_length=100):
        """格式化分组文件显示 - 完整显示所有文件"""
        if not groups:
            return []
            
        lines = []
        
        for dir_path, files in groups.items():
            # 格式化目录显示
            if dir_path:
                dir_prefix = f"[处理] {dir_path} → "
            else:
                dir_prefix = "[处理] "
            
            # 当前行，从目录前缀开始
            current_line = dir_prefix
            
            # 添加所有文件名
            for i, filename in enumerate(files):
                if i > 0:
                    current_line += ", "
                
                # 检查添加当前文件名后是否会超出行长度
                test_line = current_line + filename
                
                # 如果超出长度且不是第一个文件，则换行
                if len(test_line) > max_line_length and i > 0:
                    lines.append(current_line.rstrip(", "))
                    # 新行缩进对齐，使用空格对齐到箭头后
                    indent = " " * (len(dir_prefix))
                    current_line = indent + filename
                else:
                    current_line += filename
            
            # 添加当前目录的最后一行
            if current_line.strip():
                lines.append(current_line)
        
        return lines
    
    def preview_file(self, file_path):
        """预览模式：显示将要添加的Front Matter但不修改文件"""
        try:
            file_path = Path(file_path)
            if not file_path.exists():
                error_msg = f"文件不存在"
                self.log_verbose(f"[错误] 文件不存在: {file_path}")
                self.error_files.append((file_path, error_msg))
                self.error_count += 1
                return False

            if file_path.suffix.lower() != '.md':
                self.log_verbose(f"[警告] 跳过非Markdown文件: {file_path}")
                self.skipped_count += 1
                return False

            # 检测文件编码
            encoding = self.detect_encoding(file_path)
            
            # 读取文件内容
            with open(file_path, 'r', encoding=encoding) as f:
                content = f.read()

            # 检查是否已有Front Matter
            if self.has_frontmatter(content):
                self.log_verbose(f"[跳过] {file_path.name} - 已有Front Matter")
                self.skipped_files.append(file_path)
                self.skipped_count += 1
                return True

            # 生成Front Matter（预览）
            title = self.generate_title_from_filename(file_path)
            date = self.get_file_creation_time(file_path)
            
            front_matter = self.template.format(
                title=title,
                date=date
            )

            # 显示预览信息
            print(f"\n[预览] {file_path}")
            print("--- 将要添加的Front Matter ---")
            print(front_matter.rstrip())
            print("---------------------------")
            
            # 收集预览结果
            self.preview_files.append(file_path)
            self.processed_count += 1
            return True

        except Exception as e:
            error_msg = f"预览出错: {str(e)}"
            self.log_verbose(f"[错误] 预览文件时出错: {e}")
            self.error_files.append((file_path, error_msg))
            self.error_count += 1
            return False

    def parse_title_template(self, front_matter_content):
        """解析title模板类型，确定title生成模式"""
        try:
            # 查找title行
            lines = front_matter_content.split('\n')
            title_line = None
            for line in lines:
                if line.strip().lower().startswith('title:'):
                    title_line = line.strip()
                    break
            
            if not title_line:
                self.log_verbose(f"[模板分析] 未找到title字段，使用默认模式")
                return 'fallback'
            
            # 提取引号内的内容
            if '"' in title_line:
                # 查找第一个和最后一个引号之间的内容
                first_quote = title_line.find('"')
                last_quote = title_line.rfind('"')
                if first_quote != -1 and last_quote != -1 and first_quote != last_quote:
                    title_template = title_line[first_quote+1:last_quote]
                else:
                    self.log_verbose(f"[模板分析] 无法解析引号内容，使用默认模式")
                    return 'fallback'
            else:
                self.log_verbose(f"[模板分析] 未找到引号，使用默认模式")
                return 'fallback'
            
            self.log_verbose(f"[模板分析] 原始title模板: {title_template}")
            
            # 判断模板类型
            if '{{ .File.ContentBaseName }}' in title_template:
                # 原样使用文件名
                self.log_verbose(f"[模板分析] 检测到原样模式: 使用文件名原样作为title")
                return 'as_is'
            elif 'replace .File.ContentBaseName' in title_template and 'title' in title_template:
                # 格式化模式：替换连字符并标题化
                self.log_verbose(f"[模板分析] 检测到格式化模式: 替换连字符并标题化")
                return 'formatted'
            else:
                # 其他情况使用回退模式
                self.log_verbose(f"[模板分析] 未识别的模板格式，使用回退模式: {title_template}")
                self.log_verbose(f"[TODO] 未来可扩展支持该模板格式")
                # TODO 未来可扩展支持该模板格式
                return 'fallback'
                
        except Exception as e:
            self.log_verbose(f"[模板分析] 解析title模板时出错: {e}")
            return 'fallback'

    def load_template(self):
        """从archetypes/default.md加载Front Matter模板"""
        try:
            if not self.archetype_path.exists():
                raise FileNotFoundError(f"模板文件不存在: {self.archetype_path}")
            
            # 检测编码并读取文件
            encoding = self.detect_encoding_simple(self.archetype_path)
            with open(self.archetype_path, 'r', encoding=encoding) as f:
                content = f.read()
            
            # 提取Front Matter部分
            if not content.strip().startswith('---'):
                raise ValueError("模板文件格式错误：必须以 --- 开头")
            
            # 查找两个 --- 之间的内容
            parts = content.split('---', 2)
            if len(parts) < 3:
                raise ValueError("模板文件格式错误：缺少结束的 ---")
            
            front_matter = parts[1].strip()
            
            # 解析title模板类型并设置生成模式
            self.title_generation_mode = self.parse_title_template(front_matter)
            self.log_verbose(f"[模板] title生成模式: {self.title_generation_mode}")
            
            # 处理Hugo模板语法，转换为Python格式化字符串
            # 替换 {{ replace .File.ContentBaseName "-" " " | title }} 为 {title}
            front_matter = re.sub(r'title:\s*".*?{{\s*.*?\s*}}"', 'title: "{title}"', front_matter)
            # 替换 {{ .Date }} 为 {date}
            front_matter = re.sub(r'{{\s*\.Date\s*}}', '{date}', front_matter)
            
            # 构建完整模板
            template = f"---\n{front_matter}\n---\n\n"
            
            self.log_verbose(f"[模板] 成功加载模板: {self.archetype_path}")
            return template
            
        except Exception as e:
            self.log_verbose(f"[错误] 加载模板失败: {e}")
            self.log_verbose(f"[错误] 模板路径: {self.archetype_path}")
            # 返回默认模板作为回退
            default_template = """---
title: "{title}"
#slug: ""
description: "Meta标签 页面描述"
#summary: "文章预览 内容摘要"
date: {date}
#lastmod: {date}
draft: false
categories: []
tags: []
---

"""
            # 设置内置模板的title生成模式为fallback（文件名原样）
            self.title_generation_mode = 'fallback'
            self.log_verbose(f"[模板] 内置模板title生成模式: {self.title_generation_mode}")
            self.log_verbose("[警告] 使用内置默认模板")
            return default_template

    def detect_encoding_simple(self, file_path):
        """简单的编码检测方法（用于模板加载）"""
        # 尝试常见编码格式
        encodings = ['utf-8', 'gbk', 'gb2312', 'utf-16']
        
        for encoding in encodings:
            try:
                with open(file_path, 'r', encoding=encoding) as f:
                    f.read()
                return encoding
            except (UnicodeDecodeError, UnicodeError):
                continue
        
        # 如果都失败了，使用utf-8
        return 'utf-8'

    def detect_encoding(self, file_path):
        """检测文件编码"""
        # 尝试常见编码格式
        encodings = ['utf-8', 'gbk', 'gb2312', 'utf-16']
        
        for encoding in encodings:
            try:
                with open(file_path, 'r', encoding=encoding) as f:
                    f.read()
                return encoding
            except (UnicodeDecodeError, UnicodeError):
                continue
        
        # 如果都失败了，使用utf-8并忽略错误
        return 'utf-8'

    def has_frontmatter(self, content):
        """检查内容是否已有Front Matter"""
        # 检查是否以---开头
        return content.strip().startswith('---')

    def generate_title_from_filename(self, file_path):
        """根据模板模式从文件名生成标题"""
        filename = Path(file_path).stem
        
        if self.title_generation_mode == 'as_is':
            # 原样模式：直接使用文件名
            title = filename
            self.log_verbose(f"  [title生成] 原样模式: {title}")
        elif self.title_generation_mode == 'formatted':
            # 格式化模式：替换连字符和下划线为空格，并进行标题化
            title = filename.replace('-', ' ').replace('_', ' ').title()
            self.log_verbose(f"  [title生成] 格式化模式: {filename} -> {title}")
        else:
            # 回退模式：使用文件名原样（安全选择）
            title = filename
            self.log_verbose(f"  [title生成] 回退模式: {title}")
        
        return title

    def get_file_creation_time(self, file_path):
        """获取文件创建时间"""
        try:
            # Windows系统使用st_ctime，Unix系统使用st_birthtime（如果支持）
            stat = os.stat(file_path)
            if hasattr(stat, 'st_birthtime'):
                # macOS和一些Unix系统
                creation_time = stat.st_birthtime
            else:
                # Windows和其他系统，使用修改时间作为创建时间的近似
                creation_time = stat.st_mtime
            
            # 转换为ISO格式，包含时区信息
            dt = datetime.fromtimestamp(creation_time)
            return dt.strftime('%Y-%m-%dT%H:%M:%S+08:00')
        except:
            # 如果获取失败，使用当前时间
            return datetime.now().strftime('%Y-%m-%dT%H:%M:%S+08:00')

    def create_backup(self, file_path):
        """创建文件备份"""
        try:
            file_path = Path(file_path)
            timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
            backup_name = f"{file_path.stem}_{timestamp}.md.backup"
            backup_path = self.backup_dir / backup_name
            
            shutil.copy2(file_path, backup_path)
            self.created_backups.append((file_path, backup_path))
            self.log_verbose(f"  [备份] 备份创建: {backup_path}")
            return backup_path
        except Exception as e:
            self.log_verbose(f"  [错误] 备份失败: {e}")
            return None

    def restore_from_backup(self, original_path, backup_path):
        """从备份恢复文件"""
        try:
            shutil.copy2(backup_path, original_path)
            self.log_verbose(f"  [恢复] 已从备份恢复: {original_path}")
            return True
        except Exception as e:
            self.log_verbose(f"  [错误] 恢复失败: {e}")
            return False

    def process_file(self, file_path):
        """处理单个文件"""
        # 预览模式下调用专门的预览方法
        if self.preview_mode:
            return self.preview_file(file_path)
            
        try:
            file_path = Path(file_path)
            if not file_path.exists():
                error_msg = f"文件不存在"
                self.log_verbose(f"[错误] 文件不存在: {file_path}")
                self.error_files.append((file_path, error_msg))
                self.error_count += 1
                return False

            if file_path.suffix.lower() != '.md':
                self.log_verbose(f"[警告] 跳过非Markdown文件: {file_path}")
                self.skipped_count += 1
                return False

            self.log_verbose(f"\n[处理] 处理文件: {file_path}")

            # 检测文件编码
            encoding = self.detect_encoding(file_path)
            
            # 读取文件内容
            with open(file_path, 'r', encoding=encoding) as f:
                content = f.read()

            # 检查是否已有Front Matter
            if self.has_frontmatter(content):
                self.log_verbose(f"  [跳过] 已有Front Matter，跳过")
                self.skipped_files.append(file_path)
                self.skipped_count += 1
                return True

            # 创建备份
            backup_path = self.create_backup(file_path)
            if not backup_path:
                error_msg = f"无法创建备份"
                self.log_verbose(f"  [错误] 无法创建备份，跳过处理")
                self.error_files.append((file_path, error_msg))
                self.error_count += 1
                return False

            # 生成Front Matter
            title = self.generate_title_from_filename(file_path)
            date = self.get_file_creation_time(file_path)
            
            front_matter = self.template.format(
                title=title,
                date=date
            )

            # 添加Front Matter到内容开头
            new_content = front_matter + content

            # 写入文件
            try:
                with open(file_path, 'w', encoding='utf-8') as f:
                    f.write(new_content)
                
                self.log_verbose(f"  [成功] Front Matter已添加")
                self.log_verbose(f"     标题: {title}")
                self.log_verbose(f"     日期: {date}")
                self.processed_files.append(file_path)
                self.processed_count += 1
                return True

            except Exception as e:
                error_msg = f"写入失败: {str(e)}"
                self.log_verbose(f"  [错误] 写入文件失败: {e}")
                # 尝试从备份恢复
                self.restore_from_backup(file_path, backup_path)
                self.error_files.append((file_path, error_msg))
                self.error_count += 1
                return False

        except Exception as e:
            error_msg = f"处理出错: {str(e)}"
            self.log_verbose(f"[错误] 处理文件时出错: {e}")
            self.error_files.append((file_path, error_msg))
            self.error_count += 1
            return False

    def is_absolute_path(self, path):
        """判断是否为绝对路径"""
        path_str = str(path)
        # Windows: C:\ 或 \\ 开头
        if os.name == 'nt':
            return (len(path_str) >= 3 and path_str[1] == ':') or path_str.startswith('\\\\')
        # Unix/Linux: / 开头
        else:
            return path_str.startswith('/')

    def resolve_path(self, path_arg):
        """解析路径参数"""
        if self.is_absolute_path(path_arg):
            return Path(path_arg).resolve()
        else:
            # 相对路径，相对于当前工作目录
            return Path.cwd() / path_arg

    def collect_markdown_files(self, path):
        """收集指定路径下的所有Markdown文件"""
        path = Path(path)
        markdown_files = []
        
        if path.is_file():
            if path.suffix.lower() == '.md':
                markdown_files.append(path)
        elif path.is_dir():
            # 递归搜索目录中的所有.md文件
            markdown_files = list(path.rglob('*.md'))
        
        return markdown_files

    def process_paths(self, paths):
        """处理多个路径参数"""
        all_files = []
        
        for path_arg in paths:
            resolved_path = self.resolve_path(path_arg)
            
            if not resolved_path.exists():
                self.log_verbose(f"[错误] 路径不存在: {resolved_path}")
                self.error_count += 1
                continue
            
            files = self.collect_markdown_files(resolved_path)
            all_files.extend(files)
        
        # 去重并排序
        unique_files = sorted(set(all_files))
        
        if not unique_files:
            self.log_default("[错误] 没有找到Markdown文件")
            return False

        self.log_verbose(f"[搜索] 找到 {len(unique_files)} 个Markdown文件")
        
        # 处理所有文件
        for file_path in unique_files:
            self.process_file(file_path)
        
        return True

    def print_summary(self):
        """打印处理摘要"""
        elapsed_time = time.time() - self.start_time
        
        if self.log_level == LogLevel.QUIET:
            # 静默模式：只显示统计结果
            if self.preview_mode:
                print(f"预览完成: WILL{self.processed_count} SKIP{self.skipped_count} ERR{self.error_count}")
            else:
                print(f"处理完成: OK{self.processed_count} SKIP{self.skipped_count} ERR{self.error_count}")
            return
        
        if self.log_level == LogLevel.DEFAULT:
            # 默认模式：紧凑结构化输出
            total_files = self.processed_count + self.skipped_count + self.error_count
            
            # 显示处理结果
            files_to_show = self.preview_files if self.preview_mode else self.processed_files
            if files_to_show:
                # 按目录分组显示处理的文件
                processed_groups = self.group_files_by_directory(files_to_show)
                lines = self.format_grouped_files(processed_groups)
                for line in lines:
                    # 预览模式使用不同的标签
                    if self.preview_mode:
                        print(line.replace("[处理]", "[预览]"))
                    else:
                        print(line)
            
            # 显示跳过和错误信息
            info_parts = []
            if self.skipped_count > 0:
                if self.skipped_count <= 5:
                    # 如果跳过文件不多，可以简单提及
                    info_parts.append(f"跳过 {self.skipped_count} 个已有Front Matter的文件")
                else:
                    info_parts.append(f"跳过 {self.skipped_count} 个文件")
            
            if self.error_files:
                error_names = ", ".join([f.name for f, _ in self.error_files[:2]])
                if len(self.error_files) > 2:
                    error_names += f"... ({len(self.error_files)}个)"
                info_parts.append(f"错误: {error_names}")
            
            if info_parts:
                print(f"[跳过] {' | '.join(info_parts)}")
            elif self.skipped_count > 0 and self.processed_count == 0:
                print(f"[结果] 所有 {total_files} 个文件已有Front Matter，无需处理")
            
            # 最终统计
            status_parts = []
            if self.processed_count > 0:
                if self.preview_mode:
                    status_parts.append(f"WILL处理 {self.processed_count}")
                else:
                    status_parts.append(f"OK处理 {self.processed_count}")
            if self.skipped_count > 0:
                status_parts.append(f"SKIP跳过 {self.skipped_count}")
            if self.error_count > 0:
                status_parts.append(f"ERR错误 {self.error_count}")
                
            backup_info = f"备份: {len(self.created_backups)}个" if self.created_backups else ""
            time_info = f"用时: {elapsed_time:.1f}s"
            
            final_parts = [" ".join(status_parts)]
            if backup_info and not self.preview_mode:  # 预览模式不显示备份信息
                final_parts.append(backup_info)
            final_parts.append(time_info)
            
            completion_label = "[预览完成]" if self.preview_mode else "[完成]"
            print(f"{completion_label} {' | '.join(final_parts)}")
            
            # 预览模式的提示
            if self.preview_mode and self.processed_count > 0:
                print("[提示] 使用不带 --preview/-p 参数来实际执行修改")
            
        elif self.log_level == LogLevel.VERBOSE:
            # 详细模式：显示完整信息
            print(f"\n" + "="*50)
            print(f"[摘要] 处理完成摘要:")
            print(f"  [成功] 成功处理: {self.processed_count} 个文件")
            print(f"  [跳过] 跳过文件: {self.skipped_count} 个文件")
            print(f"  [错误] 错误文件: {self.error_count} 个文件")
            print(f"  [备份] 创建备份: {len(self.created_backups)} 个文件")
            print(f"  [耗时] 总用时: {elapsed_time:.2f}s")
            
            if self.created_backups:
                print(f"\n[备份] 备份文件位置: {self.backup_dir}")
                
            if self.error_files:
                print(f"\n[错误详情]")
                for file_path, error_msg in self.error_files:
                    print(f"  - {file_path.name}: {error_msg}")

def main():
    parser = argparse.ArgumentParser(
        description='Hugo博客Front Matter自动添加工具',
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
使用示例:
  python add_frontmatter.py                    # 默认处理 content/ 目录
  uv run add_frontmatter.py                    # 默认处理 content/ 目录
  python add_frontmatter.py article1.md article2.md
  python add_frontmatter.py posts/
  python add_frontmatter.py /absolute/path/to/article.md
  python add_frontmatter.py ../drafts/ current.md
  python add_frontmatter.py -p posts/          # 预览模式
  python add_frontmatter.py -d article.md      # 调试模式
  python add_frontmatter.py -v                 # 显示版本
        """
    )
    
    parser.add_argument(
        'paths',
        nargs='*',  # 改为 '*' 允许0个或多个参数
        help='要处理的文件或目录路径（支持多个）。不指定时默认处理 content/ 目录'
    )
    
    parser.add_argument(
        '--preview', '-p',
        action='store_true',
        help='预览模式，显示将要添加的Front Matter但不实际修改文件'
    )
    
    parser.add_argument(
        '--debug', '-d',
        action='store_true',
        help='调试输出模式，显示完整的处理过程和调试信息'
    )
    
    parser.add_argument(
        '--quiet', '-q',
        action='store_true',
        help='静默模式，只显示最终统计结果'
    )
    
    parser.add_argument(
        '--version', '-v',
        action='version',
        version=f'%(prog)s {__version__}',
        help='显示版本信息'
    )
    
    args = parser.parse_args()
    
    # 确定日志级别
    if args.quiet:
        log_level = LogLevel.QUIET
    elif args.debug:
        log_level = LogLevel.VERBOSE
    else:
        log_level = LogLevel.DEFAULT
        
    # 参数冲突检查
    if args.quiet and args.debug:
        print("[错误] --quiet 和 --debug 不能同时使用")
        return 1
    
    # 初始化处理器（会进行路径查找）
    processor = FrontMatterProcessor(log_level=log_level, preview_mode=args.preview)
    
    # 根据日志级别显示启动信息
    if log_level == LogLevel.QUIET:
        pass  # 静默模式不显示启动信息
    elif log_level == LogLevel.DEFAULT:
        # 默认模式：简洁启动信息
        project_name = processor.project_root.name
        total_files = len(list(processor.content_path.rglob('*.md'))) if processor.content_path.exists() else 0
        scan_path = processor.content_path.name if processor.content_path else "未知"
        print(f"[启动] Hugo Front Matter 工具 | 项目: {project_name} | 扫描: {scan_path} | 找到 {total_files} 个文件")
    else:  # VERBOSE
        # 详细模式：完整启动信息
        print("[启动] Hugo Front Matter 自动添加工具")
        print(f"[信息] 当前工作目录: {Path.cwd()}")
        print(f"[信息] 项目根目录: {processor.project_root}")
        print(f"[信息] 备份目录: {processor.backup_dir}")
    
    # 如果没有指定路径参数，使用默认的 content/ 目录
    if not args.paths:
        if processor.content_path and processor.content_path.exists():
            processor.log_verbose(f"[默认] 使用默认 content 目录: {processor.content_path}")
            args.paths = [str(processor.content_path)]
        else:
            processor.log_default(f"[错误] 未找到 content 目录: {processor.content_path}")
            processor.log_default(f"[提示] 请指定要处理的文件或目录路径")
            if log_level != LogLevel.QUIET:
                parser.print_help()
            return 1
    
    # 预览模式的提示在处理器初始化时已处理
    
    try:
        processor.process_paths(args.paths)
        processor.print_summary()
        return 0
    
    except KeyboardInterrupt:
        print(f"\n[中断] 用户中断操作")
        return 1
    except Exception as e:
        print(f"\n[错误] 程序出错: {e}")
        return 1

if __name__ == '__main__':
    sys.exit(main())