@tnotesjs/core 0.1.0

package/dist/cli/index.js

@@ -0,0 +1,4199 @@
+#!/usr/bin/env node
+import {
+  CONSTANTS,
+  ConfigManager,
+  EN_WORDS_DIR,
+  EOL,
+  Logger,
+  NOTES_DIR_PATH,
+  NOTES_PATH,
+  NoteManager,
+  REPO_NOTES_URL,
+  ROOT_CONFIG_PATH,
+  ROOT_DIR_PATH,
+  ROOT_README_PATH,
+  TNOTES_BASE_DIR,
+  TNOTES_CORE_DIR,
+  VP_SIDEBAR_PATH,
+  buildNoteLineMarkdown,
+  createAddNumberToTitle,
+  createError,
+  createLogger,
+  ensureDirectory,
+  genHierarchicalSidebar,
+  generateToc,
+  getChangedIds,
+  getTargetDirs,
+  handleError,
+  isPortInUse,
+  killPortProcess,
+  logger,
+  parseArgs,
+  parseNoteLine,
+  parseReadmeCompletedNotes,
+  processEmptyLines,
+  pullAllRepos,
+  pushAllRepos,
+  runCommand,
+  syncAllRepos,
+  validateNoteTitle,
+  waitForPort
+} from "../chunk-K3X5OP3N.js";
+
+// commands/models.ts
+var COMMAND_NAMES = {
+  BUILD: "build",
+  CREATE_NOTES: "create-notes",
+  DEV: "dev",
+  FIX_TIMESTAMPS: "fix-timestamps",
+  HELP: "help",
+  PREVIEW: "preview",
+  PULL: "pull",
+  PUSH: "push",
+  RENAME_NOTE: "rename-note",
+  SYNC_CORE: "sync-core",
+  SYNC: "sync",
+  UPDATE: "update",
+  UPDATE_COMPLETED_COUNT: "update-completed-count",
+  UPDATE_NOTE_CONFIG: "update-note-config"
+};
+var COMMAND_DESCRIPTIONS = {
+  [COMMAND_NAMES.DEV]: "\u542F\u52A8\u77E5\u8BC6\u5E93\u5F00\u53D1\u670D\u52A1",
+  [COMMAND_NAMES.BUILD]: "\u6784\u5EFA\u77E5\u8BC6\u5E93",
+  [COMMAND_NAMES.PREVIEW]: "\u9884\u89C8\u6784\u5EFA\u540E\u7684\u77E5\u8BC6\u5E93",
+  [COMMAND_NAMES.UPDATE]: "\u6839\u636E\u7B14\u8BB0\u5185\u5BB9\u66F4\u65B0\u77E5\u8BC6\u5E93",
+  [COMMAND_NAMES.UPDATE_COMPLETED_COUNT]: "\u66F4\u65B0\u5B8C\u6210\u7B14\u8BB0\u6570\u91CF\u5386\u53F2\u8BB0\u5F55\uFF08\u8FD1 1 \u5E74\uFF0C\u6700\u8FD1 12 \u4E2A\u6708\uFF09",
+  [COMMAND_NAMES.CREATE_NOTES]: "\u65B0\u5EFA\u7B14\u8BB0\uFF08\u652F\u6301\u6279\u91CF\u521B\u5EFA\uFF09",
+  [COMMAND_NAMES.PUSH]: "\u5C06\u77E5\u8BC6\u5E93\u63A8\u9001\u5230 GitHub (\u4F7F\u7528 --all \u63A8\u9001\u6240\u6709\u77E5\u8BC6\u5E93)",
+  [COMMAND_NAMES.PULL]: "\u5C06 GitHub \u7684\u77E5\u8BC6\u5E93\u62C9\u4E0B\u6765 (\u4F7F\u7528 --all \u62C9\u53D6\u6240\u6709\u77E5\u8BC6\u5E93)",
+  [COMMAND_NAMES.SYNC]: "\u540C\u6B65\u672C\u5730\u548C\u8FDC\u7A0B\u7684\u77E5\u8BC6\u5E93\u72B6\u6001 (\u4F7F\u7528 --all \u540C\u6B65\u6240\u6709\u77E5\u8BC6\u5E93)",
+  [COMMAND_NAMES.SYNC_CORE]: "\u540C\u6B65\u6240\u6709\u5144\u5F1F\u77E5\u8BC6\u5E93\u7684 TNotes.core \u5230\u6700\u65B0\u7248\u672C",
+  [COMMAND_NAMES.FIX_TIMESTAMPS]: "\u4FEE\u590D\u6240\u6709\u7B14\u8BB0\u7684\u65F6\u95F4\u6233\uFF08\u57FA\u4E8E git \u5386\u53F2\uFF09",
+  [COMMAND_NAMES.UPDATE_NOTE_CONFIG]: "\u66F4\u65B0\u7B14\u8BB0\u914D\u7F6E\u6587\u4EF6",
+  [COMMAND_NAMES.RENAME_NOTE]: "\u91CD\u547D\u540D\u7B14\u8BB0",
+  [COMMAND_NAMES.HELP]: "\u663E\u793A\u5E2E\u52A9\u4FE1\u606F"
+};
+var COMMAND_OPTIONS = {
+  ALL: "all",
+  QUIET: "quiet",
+  FORCE: "force"
+};
+
+// commands/BaseCommand.ts
+var BaseCommand = class {
+  constructor(name) {
+    this.name = name;
+    this.options = {};
+    this.logger = logger.child(name);
+  }
+  /** 命令描述（从静态配置读取） */
+  get description() {
+    return COMMAND_DESCRIPTIONS[this.name];
+  }
+  /**
+   * 设置命令选项
+   */
+  setOptions(options) {
+    this.options = { ...this.options, ...options };
+  }
+  /**
+   * 执行命令（带错误处理）
+   */
+  async execute() {
+    const startTime = Date.now();
+    try {
+      this.logger.start(this.description);
+      await this.run();
+      const duration = Date.now() - startTime;
+      this.logger.done(`\u547D\u4EE4\u6267\u884C\u8017\u65F6\uFF1A${duration} ms`);
+    } catch (error) {
+      handleError(error);
+      throw error;
+    }
+  }
+};
+
+// services/file-watcher/internal.ts
+var WATCH_EVENT_TYPES = {
+  README: "readme",
+  CONFIG: "config"
+};
+async function safeExecute(label, fn, logger2) {
+  try {
+    await fn();
+    return true;
+  } catch (error) {
+    logger2.error(`[${label}] ${error}`);
+    return false;
+  }
+}
+
+// services/file-watcher/watchState.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { createHash } from "crypto";
+import { join } from "path";
+var WatchState = class {
+  constructor(config) {
+    this.config = config;
+    /** 文件哈希缓存 */
+    this.fileHashes = /* @__PURE__ */ new Map();
+    /** 笔记目录缓存 */
+    this.noteDirCache = /* @__PURE__ */ new Set();
+    /** 笔记配置缓存 */
+    this.configCache = /* @__PURE__ */ new Map();
+  }
+  /**
+   * 获取指定文件的 MD5 哈希值，若文件不存在或读取失败返回 null
+   *
+   * @param filePath 文件路径
+   * @returns 文件哈希
+   */
+  getFileHash(filePath) {
+    try {
+      if (!existsSync(filePath)) return null;
+      const content = readFileSync(filePath, "utf-8");
+      if (content.length === 0) return null;
+      return createHash("md5").update(content).digest("hex");
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 更新文件哈希缓存，只有当文件内容发生变化时才更新并返回 true
+   *
+   * @param filePath 文件路径
+   * @returns 是否发生变化
+   */
+  updateFileHash(filePath) {
+    const current = this.getFileHash(filePath);
+    if (!current) return false;
+    const prev = this.fileHashes.get(filePath);
+    if (prev === current) return false;
+    this.fileHashes.set(filePath, current);
+    return true;
+  }
+  /**
+   * 检查指定名称的笔记目录是否已存在于缓存中
+   *
+   * @param name 笔记目录名称
+   * @returns 若存在则返回 true，否则返回 false
+   */
+  hasNoteDir(name) {
+    return this.noteDirCache.has(name);
+  }
+  /**
+   * 将指定名称的笔记目录添加到缓存中
+   *
+   * @param name 笔记目录名称
+   */
+  addNoteDir(name) {
+    this.noteDirCache.add(name);
+  }
+  /**
+   * 从缓存中移除指定名称的笔记目录
+   *
+   * @param name 笔记目录名称
+   */
+  deleteNoteDir(name) {
+    this.noteDirCache.delete(name);
+  }
+  /**
+   * 清空所有缓存数据，包括文件哈希、笔记目录和配置快照
+   */
+  clearAll() {
+    this.fileHashes.clear();
+    this.noteDirCache.clear();
+    this.configCache.clear();
+  }
+  /**
+   * 清除指定笔记目录相关的缓存数据，包括 README.md 和 .tnotes.json 的文件哈希及配置快照
+   *
+   * @param noteDirName 笔记目录名称
+   */
+  clearNoteCaches(noteDirName) {
+    const readmePath = join(this.config.notesDir, noteDirName, "README.md");
+    const configPath = join(this.config.notesDir, noteDirName, ".tnotes.json");
+    this.fileHashes.delete(readmePath);
+    this.fileHashes.delete(configPath);
+    this.configCache.delete(configPath);
+  }
+  /**
+   * 获取指定配置文件路径对应的配置快照
+   *
+   * @param configPath 配置文件路径（通常为 .tnotes.json 的绝对路径）
+   * @returns 配置快照，若不存在则返回 undefined
+   */
+  getConfigSnapshot(configPath) {
+    return this.configCache.get(configPath);
+  }
+  /**
+   * 设置指定配置文件路径的配置快照到缓存中
+   *
+   * @param configPath 配置文件路径（通常为 .tnotes.json 的绝对路径）
+   * @param snapshot 配置快照对象
+   */
+  setConfigSnapshot(configPath, snapshot) {
+    this.configCache.set(configPath, snapshot);
+  }
+  /**
+   * 读取指定配置文件的快照
+   *
+   * 解析 .tnotes.json 配置文件，提取 done、enableDiscussions、description 字段。
+   *
+   * @param configPath 配置文件路径（通常为 .tnotes.json 的绝对路径）
+   * @returns 配置快照，若文件不存在或解析失败则返回 null
+   */
+  readConfigSnapshot(configPath) {
+    try {
+      if (!existsSync(configPath)) return null;
+      const content = readFileSync(configPath, "utf-8");
+      const config = JSON.parse(content);
+      return {
+        done: Boolean(config.done),
+        enableDiscussions: Boolean(config.enableDiscussions),
+        description: config.description || ""
+      };
+    } catch (error) {
+      this.config.logger.error(`[\u8BFB\u53D6\u914D\u7F6E\u5FEB\u7167] ${error}`);
+      return null;
+    }
+  }
+  /**
+   * 从磁盘初始化监听状态缓存：
+   * 遍历笔记根目录下的所有子目录，将每个笔记目录的 README.md 和 .tnotes.json
+   * 的哈希值及配置快照加载到缓存中。
+   */
+  initializeFromDisk() {
+    try {
+      const noteDirs = readdirSync(this.config.notesDir);
+      this.clearAll();
+      for (const noteDir of noteDirs) {
+        const noteDirPath = join(this.config.notesDir, noteDir);
+        if (!statSync(noteDirPath).isDirectory()) continue;
+        this.noteDirCache.add(noteDir);
+        const readmePath = join(noteDirPath, "README.md");
+        const readmeHash = this.getFileHash(readmePath);
+        if (readmeHash) this.fileHashes.set(readmePath, readmeHash);
+        const configPath = join(noteDirPath, ".tnotes.json");
+        const configHash = this.getFileHash(configPath);
+        if (configHash) {
+          this.fileHashes.set(configPath, configHash);
+          const snapshot = this.readConfigSnapshot(configPath);
+          if (snapshot) this.configCache.set(configPath, snapshot);
+        }
+      }
+    } catch (error) {
+      this.config.logger.warn(
+        `[initializeFromDisk] \u521D\u59CB\u5316\u76D1\u542C\u72B6\u6001\u5931\u8D25: ${error}`
+      );
+    }
+  }
+};
+
+// services/file-watcher/eventScheduler.ts
+var DEFAULT_DEBOUNCE_MS = 1e3;
+var DEFAULT_BATCH_WINDOW_MS = 1e3;
+var DEFAULT_BATCH_THRESHOLD = 3;
+var DEFAULT_BATCH_BUFFER_MS = 2e3;
+var EventScheduler = class {
+  constructor(config) {
+    this.config = config;
+    /** 待处理的文件变更事件队列 */
+    this.pendingEvents = /* @__PURE__ */ new Map();
+    /** 防抖定时器 */
+    this.updateTimer = null;
+    /** 批量更新恢复定时器 */
+    this.batchResumeTimer = null;
+    /** 记录最近的变更时间戳 */
+    this.recentChanges = [];
+    /** 标记是否正在更新，避免循环触发 - 类似一把更新行为锁 */
+    this.isUpdating = false;
+    this.debounceMs = config.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    this.batchWindowMs = config.batchWindowMs ?? DEFAULT_BATCH_WINDOW_MS;
+    this.batchThreshold = config.batchThreshold ?? DEFAULT_BATCH_THRESHOLD;
+    this.batchBufferMs = config.batchBufferMs ?? DEFAULT_BATCH_BUFFER_MS;
+  }
+  /**
+   * 设置更新状态锁，用于防止在执行耗时更新操作时被新的文件变更事件打断
+   *
+   * @param flag - true 表示正在更新（锁定），false 表示更新完成（解锁）
+   */
+  setUpdating(flag) {
+    this.isUpdating = flag;
+  }
+  /**
+   * 获取当前是否处于更新锁定状态
+   *
+   * @returns true 表示正在执行更新操作（事件处理被暂停），false 表示空闲可处理新事件
+   */
+  getUpdating() {
+    return this.isUpdating;
+  }
+  /**
+   * 将文件变更事件加入待处理队列，并启动防抖定时器
+   *
+   * - 若同一文件路径的事件已存在，则忽略重复事件（去重）
+   * - 每次新事件都会重置防抖计时器，确保在变更停止后才触发处理
+   *
+   * @param event 文件变更事件
+   */
+  enqueue(event) {
+    if (this.pendingEvents.has(event.path)) return;
+    this.pendingEvents.set(event.path, event);
+    if (this.updateTimer) clearTimeout(this.updateTimer);
+    this.updateTimer = setTimeout(() => this.flush(), this.debounceMs);
+  }
+  /**
+   * 立即触发事件队列的处理（防抖到期或手动调用）
+   *
+   * - 若当前正在更新（isUpdating 为 true），则跳过以避免重复处理
+   * - 清空待处理事件队列，并通过 onFlush 回调交由上层服务处理
+   * - 处理开始后会锁定更新状态，防止处理过程中被新事件打断
+   */
+  flush() {
+    if (this.isUpdating) return;
+    if (this.pendingEvents.size === 0) return;
+    const events = Array.from(this.pendingEvents.values());
+    this.pendingEvents.clear();
+    this.isUpdating = true;
+    this.config.onFlush(events);
+  }
+  /**
+   * 记录当前变更时间并检测是否触发批量更新模式
+   *
+   * - 维护一个滑动时间窗口（BATCH_UPDATE_WINDOW_MS）内的变更记录
+   * - 若短时间内（1秒内）变更次数达到阈值（BATCH_UPDATE_THRESHOLD = 3），则判定为批量操作
+   * - 触发批量模式后：
+   *   1. 清空当前待处理事件队列，避免重复处理
+   *   2. 锁定更新状态（isUpdating = true）
+   *   3. 暂停监听服务，并在延迟（窗口 + 缓冲时间）后自动恢复
+   *
+   * @param now 当前时间戳（默认使用 Date.now()）
+   * @returns true 表示已触发批量更新模式，false 表示仍处于普通监听模式
+   */
+  recordChangeAndDetectBatch(now = Date.now()) {
+    this.recentChanges.push(now);
+    this.recentChanges = this.recentChanges.filter(
+      (t) => now - t < this.batchWindowMs
+    );
+    if (this.recentChanges.length < this.batchThreshold) return false;
+    this.pendingEvents.clear();
+    this.recentChanges = [];
+    this.isUpdating = true;
+    this.config.onPauseForBatch();
+    this.batchResumeTimer = setTimeout(() => {
+      this.batchResumeTimer = null;
+      this.isUpdating = false;
+      this.config.reinit();
+      this.config.onResumeAfterBatch();
+    }, this.batchWindowMs + this.batchBufferMs);
+    return true;
+  }
+  /**
+   * 清理所有定时器，释放资源
+   *
+   * 在服务停止时调用，防止定时器在服务销毁后仍然触发回调
+   */
+  clearTimers() {
+    if (this.updateTimer) {
+      clearTimeout(this.updateTimer);
+      this.updateTimer = null;
+    }
+    if (this.batchResumeTimer) {
+      clearTimeout(this.batchResumeTimer);
+      this.batchResumeTimer = null;
+    }
+    this.pendingEvents.clear();
+    this.recentChanges = [];
+  }
+};
+
+// services/file-watcher/renameDetector.ts
+import { existsSync as existsSync2 } from "fs";
+import { join as join2 } from "path";
+var FOLDER_RENAME_DETECT_WINDOW_MS = 500;
+var RenameDetector = class {
+  constructor(config) {
+    this.config = config;
+    /** 待处理的文件夹重命名 */
+    this.pendingFolderRename = null;
+    /** 文件夹重命名检测定时器 */
+    this.folderRenameTimer = null;
+  }
+  handleFsRename(folderName) {
+    const { notesDir, dirCache, logger: logger2, onDelete, onRename } = this.config;
+    const folderPath = join2(notesDir, folderName);
+    const folderExists = existsSync2(folderPath);
+    const noteIndex = NoteManager.extractNoteIndex(folderName);
+    if (!noteIndex) {
+      logger2.warn(`\u65E0\u6CD5\u4ECE\u6587\u4EF6\u5939\u540D\u79F0\u63D0\u53D6\u7B14\u8BB0\u7D22\u5F15: ${folderName}`);
+      return;
+    }
+    if (!folderExists) {
+      if (dirCache.has(folderName)) {
+        logger2.info(`\u68C0\u6D4B\u5230\u6587\u4EF6\u5939\u5220\u9664/\u91CD\u547D\u540D: ${folderName}`);
+        this.pendingFolderRename = { oldName: folderName, time: Date.now() };
+        if (this.folderRenameTimer) clearTimeout(this.folderRenameTimer);
+        this.folderRenameTimer = setTimeout(() => {
+          if (this.pendingFolderRename) {
+            logger2.warn(`\u68C0\u6D4B\u5230\u7B14\u8BB0\u5220\u9664: ${this.pendingFolderRename.oldName}`);
+            onDelete(this.pendingFolderRename.oldName);
+          }
+          this.pendingFolderRename = null;
+          this.folderRenameTimer = null;
+        }, FOLDER_RENAME_DETECT_WINDOW_MS);
+      }
+      return;
+    }
+    if (!dirCache.has(folderName)) {
+      logger2.info(`\u68C0\u6D4B\u5230\u6587\u4EF6\u5939\u521B\u5EFA/\u91CD\u547D\u540D: ${folderName}`);
+      if (this.pendingFolderRename && Date.now() - this.pendingFolderRename.time < FOLDER_RENAME_DETECT_WINDOW_MS) {
+        const oldName = this.pendingFolderRename.oldName;
+        const oldNoteIndex = NoteManager.extractNoteIndex(oldName);
+        if (oldNoteIndex && oldNoteIndex === noteIndex) {
+          logger2.info(`\u68C0\u6D4B\u5230\u6587\u4EF6\u5939\u91CD\u547D\u540D: ${oldName} \u2192 ${folderName}`);
+          if (this.folderRenameTimer) {
+            clearTimeout(this.folderRenameTimer);
+            this.folderRenameTimer = null;
+          }
+          onRename(oldName, folderName);
+          this.pendingFolderRename = null;
+        } else if (oldNoteIndex && oldNoteIndex !== noteIndex) {
+          logger2.warn(`\u7D22\u5F15\u51B2\u7A81\uFF0C\u56DE\u9000: ${oldName} -> ${folderName}`);
+        }
+      }
+      dirCache.add(folderName);
+      if (this.pendingFolderRename) {
+        dirCache.delete(this.pendingFolderRename.oldName);
+      }
+    }
+  }
+  clearTimers() {
+    if (this.folderRenameTimer) {
+      clearTimeout(this.folderRenameTimer);
+      this.folderRenameTimer = null;
+    }
+    this.pendingFolderRename = null;
+  }
+};
+
+// services/file-watcher/configChangeHandler.ts
+var ConfigChangeHandler = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async handle(events) {
+    if (events.length === 0) return [];
+    const changedIndexes = [];
+    const { state, noteService, noteIndexCache, logger: logger2 } = this.config;
+    for (const change of events) {
+      if (noteService.shouldIgnoreConfigChange(change.path)) {
+        logger2.debug(`\u5FFD\u7565 API \u5199\u5165\u7684\u914D\u7F6E\u6587\u4EF6: ${change.path}`);
+        continue;
+      }
+      const snapshot = state.readConfigSnapshot(change.path);
+      if (!snapshot) continue;
+      const cached = state.getConfigSnapshot(change.path);
+      state.setConfigSnapshot(change.path, snapshot);
+      noteIndexCache.updateConfig(change.noteIndex, snapshot);
+      if (!cached) continue;
+      const statusChanged = cached.done !== snapshot.done;
+      const otherChanged = cached.enableDiscussions !== snapshot.enableDiscussions || cached.description !== snapshot.description;
+      if (statusChanged) {
+        changedIndexes.push(change.noteIndex);
+        logger2.info(`\u68C0\u6D4B\u5230\u914D\u7F6E\u72B6\u6001\u53D8\u5316: done(${cached.done}\u2192${snapshot.done})`);
+      } else if (otherChanged) {
+        logger2.info("\u68C0\u6D4B\u5230\u914D\u7F6E\u975E\u72B6\u6001\u5B57\u6BB5\u53D8\u5316\uFF0C\u5DF2\u5237\u65B0\u7F13\u5B58\uFF08\u65E0\u9700\u5168\u5C40\u66F4\u65B0\uFF09");
+      }
+    }
+    return changedIndexes;
+  }
+};
+
+// services/file-watcher/readmeChangeHandler.ts
+var ReadmeChangeHandler = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async handle(events) {
+    if (events.length === 0) return;
+    const indexes = [...new Set(events.map((c) => c.noteIndex))];
+    for (const noteIndex of indexes) {
+      const noteInfo = this.config.noteService.getNoteByIndex(noteIndex);
+      if (noteInfo) {
+        await this.config.noteService.fixNoteTitle(noteInfo);
+      }
+    }
+  }
+};
+
+// services/file-watcher/globalUpdateCoordinator.ts
+var GlobalUpdateCoordinator = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async applyConfigUpdates(changedNoteIndexes) {
+    if (changedNoteIndexes.length === 0) return;
+    const { readmeService, noteIndexCache, logger: logger2 } = this.config;
+    logger2.info("\u68C0\u6D4B\u5230\u7B14\u8BB0\u72B6\u6001\u53D8\u5316\uFF0C\u589E\u91CF\u66F4\u65B0\u5168\u5C40\u6587\u4EF6...");
+    for (const noteIndex of changedNoteIndexes) {
+      await safeExecute(
+        `\u589E\u91CF\u66F4\u65B0 ${noteIndex}`,
+        async () => {
+          const item = noteIndexCache.getByNoteIndex(noteIndex);
+          await readmeService.updateNoteInReadme(
+            noteIndex,
+            item?.noteConfig || {}
+          );
+          logger2.info(`\u589E\u91CF\u66F4\u65B0 README \u4E2D\u7684\u7B14\u8BB0: ${noteIndex}`);
+        },
+        logger2
+      );
+    }
+    await readmeService.regenerateSidebar();
+  }
+  async updateNoteReadmesOnly(events) {
+    const noteIndexesToUpdate = [...new Set(events.map((c) => c.noteIndex))];
+    if (noteIndexesToUpdate.length === 0) return;
+    await this.config.readmeService.updateNoteReadmesOnly(noteIndexesToUpdate);
+  }
+};
+
+// services/file-watcher/folderChangeHandler.ts
+import { existsSync as existsSync3, promises as fsPromises } from "fs";
+import { join as join3 } from "path";
+var RENAME_REVERT_DELAY_MS = 2e3;
+var DELETE_REINIT_DELAY_MS = 1e3;
+var UPDATE_UNLOCK_DELAY_MS = 500;
+var FolderChangeHandler = class {
+  constructor(config) {
+    this.config = config;
+    /** 活跃的定时器 ID 集合，用于统一清理 */
+    this.activeTimers = /* @__PURE__ */ new Set();
+  }
+  /**
+   * 清理所有活跃定时器，释放资源
+   *
+   * 在服务停止时调用，防止定时器在服务销毁后仍然触发回调
+   */
+  clearTimers() {
+    for (const timer of this.activeTimers) {
+      clearTimeout(timer);
+    }
+    this.activeTimers.clear();
+  }
+  scheduleTimer(fn, delay) {
+    const timer = setTimeout(() => {
+      this.activeTimers.delete(timer);
+      fn();
+    }, delay);
+    this.activeTimers.add(timer);
+  }
+  async handleFolderDeletion(deletedFolderName) {
+    const { scheduler, watchState, noteIndexCache, readmeService, logger: logger2 } = this.config;
+    if (scheduler.getUpdating()) return;
+    scheduler.setUpdating(true);
+    try {
+      const noteIndex = this.extractNoteIndexOrWarn(deletedFolderName);
+      if (!noteIndex) return;
+      logger2.info(`\u6B63\u5728\u5904\u7406\u7B14\u8BB0\u5220\u9664: ${noteIndex} (${deletedFolderName})`);
+      watchState.deleteNoteDir(deletedFolderName);
+      watchState.clearNoteCaches(deletedFolderName);
+      noteIndexCache.delete(noteIndex);
+      await safeExecute(
+        `\u5220\u9664\u7B14\u8BB0 ${noteIndex}`,
+        async () => {
+          await readmeService.deleteNoteFromReadme(noteIndex);
+          await readmeService.regenerateSidebar();
+        },
+        logger2
+      );
+    } finally {
+      this.scheduleTimer(() => {
+        scheduler.setUpdating(false);
+        watchState.initializeFromDisk();
+      }, DELETE_REINIT_DELAY_MS);
+    }
+  }
+  async handleFolderRenameUpdate(oldName, newName) {
+    const { scheduler, watchState, logger: logger2 } = this.config;
+    if (scheduler.getUpdating()) return;
+    scheduler.setUpdating(true);
+    try {
+      const { oldNoteIndex, newNoteIndex } = this.validateRenameIndexes(
+        oldName,
+        newName
+      );
+      if (!oldNoteIndex || !newNoteIndex) return;
+      logger2.info(`\u6B63\u5728\u5904\u7406\u6587\u4EF6\u5939\u91CD\u547D\u540D: ${oldName} \u2192 ${newName}`);
+      if (oldNoteIndex === newNoteIndex) {
+        await safeExecute(
+          `\u6807\u9898\u91CD\u547D\u540D ${newNoteIndex}`,
+          () => this.handleTitleOnlyRename(newNoteIndex, newName),
+          logger2
+        );
+      } else {
+        await safeExecute(
+          `\u7D22\u5F15\u53D8\u66F4 ${oldNoteIndex}\u2192${newNoteIndex}`,
+          () => this.handleIndexChangedRename(oldNoteIndex, newNoteIndex),
+          logger2
+        );
+      }
+    } finally {
+      this.scheduleTimer(() => {
+        scheduler.setUpdating(false);
+        watchState.initializeFromDisk();
+      }, UPDATE_UNLOCK_DELAY_MS);
+    }
+  }
+  // #region - 私有实现
+  validateRenameIndexes(oldName, newName) {
+    const { noteIndexCache, logger: logger2 } = this.config;
+    const oldNoteIndex = this.extractNoteIndexOrWarn(oldName);
+    const newNoteIndex = this.extractNoteIndexOrWarn(newName);
+    if (!oldNoteIndex || !newNoteIndex) {
+      return { oldNoteIndex: null, newNoteIndex: null };
+    }
+    if (!/^\d{4}$/.test(newNoteIndex)) {
+      logger2.error(`\u65B0\u7B14\u8BB0\u7D22\u5F15\u683C\u5F0F\u975E\u6CD5: ${newNoteIndex}\uFF0C\u81EA\u52A8\u56DE\u9000`);
+      this.revertFolderRename(oldName, newName);
+      return { oldNoteIndex: null, newNoteIndex: null };
+    }
+    if (oldNoteIndex !== newNoteIndex && noteIndexCache.has(newNoteIndex)) {
+      logger2.error(`\u65B0\u7B14\u8BB0\u7D22\u5F15 ${newNoteIndex} \u5DF2\u5B58\u5728\uFF0C\u81EA\u52A8\u56DE\u9000`);
+      this.revertFolderRename(oldName, newName);
+      return { oldNoteIndex: null, newNoteIndex: null };
+    }
+    return { oldNoteIndex, newNoteIndex };
+  }
+  async handleTitleOnlyRename(noteIndex, newName) {
+    const { noteIndexCache, readmeService, logger: logger2 } = this.config;
+    logger2.info(`\u7B14\u8BB0\u7D22\u5F15\u672A\u53D8 (${noteIndex})\uFF0C\u53EA\u66F4\u65B0\u6807\u9898`);
+    noteIndexCache.updateFolderName(noteIndex, newName);
+    const item = noteIndexCache.getByNoteIndex(noteIndex);
+    if (item) {
+      await readmeService.updateNoteInReadme(noteIndex, item.noteConfig);
+    }
+    await readmeService.regenerateSidebar();
+    logger2.success(`\u6807\u9898\u66F4\u65B0\u5B8C\u6210`);
+  }
+  async handleIndexChangedRename(oldNoteIndex, newNoteIndex) {
+    const { noteService, noteIndexCache, readmeService, logger: logger2 } = this.config;
+    logger2.info(`\u7B14\u8BB0\u7D22\u5F15\u53D8\u66F4: ${oldNoteIndex} \u2192 ${newNoteIndex}`);
+    await readmeService.deleteNoteFromReadme(oldNoteIndex);
+    const newNote = noteService.getNoteByIndex(newNoteIndex);
+    if (newNote) {
+      noteIndexCache.delete(oldNoteIndex);
+      noteIndexCache.add(newNote);
+      await readmeService.appendNoteToReadme(newNoteIndex);
+      await readmeService.regenerateSidebar();
+      logger2.success(`\u7B14\u8BB0\u7D22\u5F15\u53D8\u66F4\u5904\u7406\u5B8C\u6210`);
+    } else {
+      logger2.error(`\u672A\u627E\u5230\u65B0\u7B14\u8BB0: ${newNoteIndex}`);
+    }
+  }
+  async revertFolderRename(oldName, newName) {
+    const { notesDir, scheduler, watchState, logger: logger2 } = this.config;
+    try {
+      const oldPath = join3(notesDir, oldName);
+      const newPath = join3(notesDir, newName);
+      if (existsSync3(newPath)) {
+        scheduler.setUpdating(true);
+        await fsPromises.rename(newPath, oldPath);
+        logger2.warn(`\u6587\u4EF6\u5939\u5DF2\u56DE\u9000: ${newName} \u2192 ${oldName}`);
+        this.scheduleTimer(() => {
+          scheduler.setUpdating(false);
+          watchState.initializeFromDisk();
+        }, RENAME_REVERT_DELAY_MS);
+      }
+    } catch (error) {
+      logger2.error(`\u56DE\u9000\u6587\u4EF6\u5939\u91CD\u547D\u540D\u5931\u8D25: ${error}`);
+    }
+  }
+  extractNoteIndexOrWarn(name) {
+    const noteIndex = name.match(/^(\d{4})/)?.[1] || null;
+    if (!noteIndex) {
+      this.config.logger.warn(`\u65E0\u6CD5\u4ECE\u6587\u4EF6\u5939\u540D\u79F0\u63D0\u53D6\u7B14\u8BB0\u7D22\u5F15: ${name}`);
+    }
+    return noteIndex;
+  }
+  // #endregion - 私有实现
+};
+
+// services/file-watcher/fsWatcherAdapter.ts
+import { watch } from "fs";
+import { basename, dirname, join as join4, sep } from "path";
+var FsWatcherAdapter = class {
+  constructor(config) {
+    this.config = config;
+    /** 文件系统监听器实例 */
+    this.watcher = null;
+  }
+  start() {
+    const { logger: logger2 } = this.config;
+    if (this.watcher) {
+      logger2.warn("\u6587\u4EF6\u76D1\u542C\u670D\u52A1\u5DF2\u542F\u52A8");
+      return;
+    }
+    this.watcher = watch(
+      this.config.notesDir,
+      { recursive: true },
+      (eventType, filename) => this.handleFsEvent(eventType, filename)
+    );
+    logger2.debug(`\u6587\u4EF6\u76D1\u542C\u5DF2\u542F\u52A8\uFF0C\u76D1\u542C\u76EE\u5F55\uFF1A${this.config.notesDir}`);
+  }
+  stop() {
+    if (!this.watcher) return;
+    this.watcher.close();
+    this.watcher = null;
+  }
+  isWatching() {
+    return this.watcher !== null;
+  }
+  handleFsEvent(eventType, filename) {
+    const { isUpdating, onRename, onNoteEvent } = this.config;
+    if (!filename || // 忽略无文件变更
+    isUpdating()) {
+      return;
+    }
+    if (eventType === "rename" && // 检测文件夹 rename 事件
+    !filename.includes(sep)) {
+      onRename(filename);
+      return;
+    }
+    const baseFilename = basename(filename);
+    if (baseFilename !== "README.md" && baseFilename !== ".tnotes.json") {
+      return;
+    }
+    const fullPath = join4(this.config.notesDir, filename);
+    const event = this.buildWatchEvent(fullPath, filename);
+    if (!event) {
+      return;
+    }
+    onNoteEvent(event);
+  }
+  buildWatchEvent(fullPath, filename) {
+    const noteDirName = basename(dirname(fullPath));
+    const noteIndex = NoteManager.extractNoteIndex(noteDirName);
+    if (!noteIndex) {
+      NoteManager.warnInvalidNoteIndex(noteDirName);
+      return null;
+    }
+    const fileType = filename.endsWith("README.md") ? WATCH_EVENT_TYPES.README : WATCH_EVENT_TYPES.CONFIG;
+    return {
+      path: fullPath,
+      type: fileType,
+      noteIndex,
+      noteDirName,
+      noteDirPath: dirname(fullPath)
+    };
+  }
+};
+
+// core/ReadmeGenerator.ts
+import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync4 } from "fs";
+
+// core/TocGenerator.ts
+var BILIBILI_VIDEO_BASE_URL = "https://www.bilibili.com/video/";
+var TNOTES_YUQUE_BASE_URL = "https://www.yuque.com/tdahuyou/tnotes.yuque/";
+var NOTES_TOC_START_TAG = "<!-- region:toc -->";
+var NOTES_TOC_END_TAG = "<!-- endregion:toc -->";
+var TocGenerator = class {
+  /**
+   * 更新笔记目录
+   * @param noteIndex - 笔记索引
+   * @param lines - 笔记内容行数组
+   * @param noteConfig - 笔记配置
+   * @param repoName - 仓库名称
+   */
+  updateNoteToc(noteIndex, lines, noteConfig, repoName) {
+    let startLineIdx = -1, endLineIdx = -1;
+    lines.forEach((line, idx) => {
+      if (line.startsWith(NOTES_TOC_START_TAG)) startLineIdx = idx;
+      if (line.startsWith(NOTES_TOC_END_TAG)) endLineIdx = idx;
+    });
+    if (startLineIdx === -1 || endLineIdx === -1) return;
+    const titles = [];
+    const numberedHeaders = ["## ", "### "];
+    const unnumberedHeaders = ["#### ", "##### ", "###### "];
+    const addNumberToTitle = createAddNumberToTitle();
+    let inCodeBlock = false;
+    let inHtmlComment = false;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.trim().startsWith("```") || line.trim().startsWith("~~~")) {
+        inCodeBlock = !inCodeBlock;
+        continue;
+      }
+      if (line.trim().startsWith("<!--")) {
+        inHtmlComment = true;
+      }
+      if (line.trim().includes("-->")) {
+        inHtmlComment = false;
+        continue;
+      }
+      if (inCodeBlock || inHtmlComment) {
+        continue;
+      }
+      const isNumberedHeader = numberedHeaders.some(
+        (header) => line.startsWith(header)
+      );
+      const isUnnumberedHeader = unnumberedHeaders.some(
+        (header) => line.startsWith(header)
+      );
+      if (isNumberedHeader) {
+        const [numberedTitle] = addNumberToTitle(line);
+        titles.push(numberedTitle);
+        lines[i] = numberedTitle;
+      } else if (isUnnumberedHeader) {
+        const match = line.match(/^(\#+)\s*(\d+(\.\d+)*\.\s*)?(.*)/);
+        if (match) {
+          const headerSymbol = match[1];
+          const plainTitle = match[4];
+          const cleanTitle = `${headerSymbol} ${plainTitle}`;
+          titles.push(cleanTitle);
+          lines[i] = cleanTitle;
+        } else {
+          titles.push(line);
+        }
+      }
+    }
+    const toc = generateToc(titles);
+    const bilibiliTOCItems = [];
+    const tnotesTOCItems = [];
+    const yuqueTOCItems = [];
+    if (noteConfig) {
+      if (noteConfig.bilibili.length > 0) {
+        noteConfig.bilibili.forEach((bvid, i) => {
+          bilibiliTOCItems.push(
+            `  - [bilibili.${repoName}.${noteIndex}.${i + 1}](${BILIBILI_VIDEO_BASE_URL + bvid})`
+          );
+        });
+      }
+      if (noteConfig.tnotes && noteConfig.tnotes.length > 0) {
+        tnotesTOCItems.push(
+          `- [\u{1F4D2} TNotes\uFF08\u76F8\u5173\u77E5\u8BC6\u5E93\uFF09](https://tnotesjs.github.io/TNotes/)`
+        );
+        noteConfig.tnotes.forEach((repoName2) => {
+          tnotesTOCItems.push(
+            `  - [TNotes.${repoName2}](https://tnotesjs.github.io/TNotes.${repoName2}/)`
+          );
+        });
+      }
+      if (noteConfig.yuque.length > 0) {
+        noteConfig.yuque.forEach((slug, i) => {
+          yuqueTOCItems.push(
+            `  - [TNotes.yuque.${repoName.replace(
+              "TNotes.",
+              ""
+            )}.${noteIndex}](${TNOTES_YUQUE_BASE_URL + slug})`
+          );
+        });
+      }
+    }
+    const insertTocItems = [];
+    const hasExternalResources = bilibiliTOCItems.length > 0 || tnotesTOCItems.length > 0 || yuqueTOCItems.length > 0;
+    if (hasExternalResources) {
+      insertTocItems.push("::: details \u{1F4DA} \u76F8\u5173\u8D44\u6E90", "");
+      if (bilibiliTOCItems.length > 0) {
+        insertTocItems.push(
+          `- [\u{1F4FA} bilibili\uFF08\u7B14\u8BB0\u89C6\u9891\u8D44\u6E90\uFF09](https://space.bilibili.com/407241004)`,
+          ...bilibiliTOCItems
+        );
+      }
+      if (tnotesTOCItems.length > 0) {
+        insertTocItems.push(...tnotesTOCItems);
+      }
+      if (yuqueTOCItems.length > 0) {
+        insertTocItems.push(
+          `- [\u{1F4C2} TNotes.yuque\uFF08\u7B14\u8BB0\u9644\u4EF6\u8D44\u6E90\uFF09](${TNOTES_YUQUE_BASE_URL})`,
+          ...yuqueTOCItems
+        );
+      }
+      insertTocItems.push("", ":::", "");
+    }
+    lines.splice(
+      startLineIdx + 1,
+      endLineIdx - startLineIdx - 1,
+      "",
+      ...insertTocItems,
+      ...toc.replace(new RegExp(`^${EOL}`), "").split(EOL)
+    );
+  }
+  /**
+   * 更新首页目录
+   * @param lines - 首页内容行数组
+   * @param titles - 标题数组
+   * @param titlesNotesCount - 每个标题下的笔记数量
+   */
+  updateHomeToc(lines, titles, titlesNotesCount) {
+    let startLineIdx = -1, endLineIdx = -1;
+    lines.forEach((line, idx) => {
+      if (line.startsWith(NOTES_TOC_START_TAG)) startLineIdx = idx;
+      if (line.startsWith(NOTES_TOC_END_TAG)) endLineIdx = idx;
+    });
+    if (startLineIdx === -1 || endLineIdx === -1) return;
+    const toc = generateToc(titles);
+    lines.splice(
+      startLineIdx + 1,
+      endLineIdx - startLineIdx - 1,
+      ...toc.split(EOL)
+    );
+  }
+};
+
+// core/ReadmeGenerator.ts
+var ReadmeGenerator = class {
+  constructor() {
+    this.tocGenerator = new TocGenerator();
+    this.configManager = ConfigManager.getInstance();
+  }
+  /**
+   * 更新笔记 README
+   * @param noteInfo - 笔记信息
+   */
+  updateNoteReadme(noteInfo) {
+    if (!noteInfo.config) {
+      logger.warn(`\u7B14\u8BB0 ${noteInfo.dirName} \u7F3A\u5C11\u914D\u7F6E\u6587\u4EF6`);
+      return;
+    }
+    const content = readFileSync2(noteInfo.readmePath, "utf-8");
+    if (content.length === 0) return;
+    const lines = content.split(EOL);
+    const repoName = this.configManager.get("repoName");
+    this.tocGenerator.updateNoteToc(
+      noteInfo.index,
+      lines,
+      noteInfo.config,
+      repoName
+    );
+    const updatedContent = lines.join(EOL);
+    writeFileSync(noteInfo.readmePath, updatedContent, "utf-8");
+  }
+  /**
+   * 更新首页 README
+   * 更新笔记链接的状态标记（[x] 或 [ ]），同时更新 TOC 区域
+   * @param notes - 笔记信息数组
+   * @param homeReadmePath - 首页 README 路径
+   */
+  updateHomeReadme(notes, homeReadmePath) {
+    if (!existsSync4(homeReadmePath)) {
+      logger.error(`\u6839\u76EE\u5F55\u4E0B\u7684 README.md \u6587\u4EF6\u672A\u627E\u5230\uFF1A${homeReadmePath}`);
+      return;
+    }
+    const content = readFileSync2(homeReadmePath, "utf-8");
+    const lines = content.split(EOL);
+    const noteByIndexMap = /* @__PURE__ */ new Map();
+    for (const note of notes) {
+      noteByIndexMap.set(note.index, note);
+    }
+    const repoOwner = this.configManager.get("author");
+    const repoName = this.configManager.get("repoName");
+    const existingNoteIndexes = /* @__PURE__ */ new Set();
+    const linesToRemove = /* @__PURE__ */ new Set();
+    const titles = [];
+    const titlesNotesCount = [];
+    let inTocRegion = false;
+    let currentNoteCount = 0;
+    const addNumberToTitle = createAddNumberToTitle();
+    const numberedHeaders = ["## ", "### "];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (line.includes("<!-- region:toc -->")) {
+        inTocRegion = true;
+        continue;
+      }
+      if (line.includes("<!-- endregion:toc -->")) {
+        inTocRegion = false;
+        continue;
+      }
+      if (inTocRegion) {
+        continue;
+      }
+      const parsed = parseNoteLine(line);
+      if (parsed.isMatch && parsed.noteIndex) {
+        const note = noteByIndexMap.get(parsed.noteIndex);
+        if (!note) {
+          linesToRemove.add(i);
+          logger.warn(`\u79FB\u9664\u4E0D\u5B58\u5728\u7684\u7B14\u8BB0: ${parsed.noteIndex}`);
+          continue;
+        }
+        existingNoteIndexes.add(parsed.noteIndex);
+        lines[i] = buildNoteLineMarkdown(note, repoOwner, repoName);
+        currentNoteCount++;
+        continue;
+      }
+      const titleMatch = line.match(/^(#{2,})\s+(.+)$/);
+      if (titleMatch) {
+        const isNumberedHeader = numberedHeaders.some(
+          (header) => line.startsWith(header)
+        );
+        if (isNumberedHeader) {
+          const [numberedTitle] = addNumberToTitle(line);
+          lines[i] = numberedTitle;
+          if (titles.length > 0) {
+            titlesNotesCount.push(currentNoteCount);
+          }
+          titles.push(numberedTitle);
+          currentNoteCount = 0;
+        } else {
+          if (titles.length > 0) {
+            titlesNotesCount.push(currentNoteCount);
+          }
+          titles.push(line);
+          currentNoteCount = 0;
+        }
+      }
+    }
+    const sortedLinesToRemove = Array.from(linesToRemove).sort((a, b) => b - a);
+    for (const lineIndex of sortedLinesToRemove) {
+      lines.splice(lineIndex, 1);
+      if (currentNoteCount > 0) {
+        currentNoteCount--;
+      }
+    }
+    const missingNotes = [];
+    for (const note of notes) {
+      if (!existingNoteIndexes.has(note.index)) {
+        missingNotes.push(note);
+      }
+    }
+    if (missingNotes.length > 0) {
+      logger.info(`\u6DFB\u52A0 ${missingNotes.length} \u7BC7\u7F3A\u5931\u7684\u7B14\u8BB0\u5230 README`);
+      missingNotes.sort((a, b) => a.index.localeCompare(b.index));
+      for (const note of missingNotes) {
+        const noteLine = buildNoteLineMarkdown(note, repoOwner, repoName);
+        lines.push(noteLine);
+        currentNoteCount++;
+      }
+    }
+    if (titles.length > 0) {
+      titlesNotesCount.push(currentNoteCount);
+    }
+    this.tocGenerator.updateHomeToc(lines, titles, titlesNotesCount);
+    const processedLines = processEmptyLines(lines);
+    const updatedContent = processedLines.join(EOL);
+    writeFileSync(homeReadmePath, updatedContent, "utf-8");
+    logger.info("\u5DF2\u66F4\u65B0\u9996\u9875 README");
+  }
+};
+
+// core/NoteIndexCache.ts
+import { join as join5 } from "path";
+var NoteIndexCache = class _NoteIndexCache {
+  constructor() {
+    /** noteIndex -> NoteIndexItem 的映射 */
+    this.byNoteIndex = /* @__PURE__ */ new Map();
+    /** configId (UUID) -> noteIndex 的映射，用于快速反向查询 */
+    this.byConfigId = /* @__PURE__ */ new Map();
+    /** 是否已完成初始化 */
+    this._initialized = false;
+  }
+  static {
+    this.instance = null;
+  }
+  /**
+   * 获取单例实例
+   */
+  static getInstance() {
+    if (!_NoteIndexCache.instance) {
+      _NoteIndexCache.instance = new _NoteIndexCache();
+    }
+    return _NoteIndexCache.instance;
+  }
+  /**
+   * 初始化索引缓存
+   * @param notes - 扫描得到的笔记列表（已由 NoteManager.scanNotes 完成重复检测）
+   */
+  initialize(notes) {
+    this.byNoteIndex.clear();
+    this.byConfigId.clear();
+    for (const note of notes) {
+      const item = {
+        noteIndex: note.index,
+        folderName: note.dirName,
+        noteConfig: note.config
+      };
+      this.byNoteIndex.set(note.index, item);
+      this.byConfigId.set(note.config.id, note.index);
+    }
+    this._initialized = true;
+  }
+  /**
+   * 是否已完成初始化
+   */
+  isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * 从缓存构建 NoteInfo 列表（纯内存，零 I/O）
+   * @returns 笔记信息数组
+   */
+  toNoteInfoList() {
+    const result = [];
+    for (const item of this.byNoteIndex.values()) {
+      const notePath = join5(NOTES_PATH, item.folderName);
+      result.push({
+        index: item.noteIndex,
+        path: notePath,
+        dirName: item.folderName,
+        readmePath: join5(notePath, "README.md"),
+        configPath: join5(notePath, ".tnotes.json"),
+        config: item.noteConfig
+      });
+    }
+    return result;
+  }
+  /**
+   * 根据 noteIndex 获取索引项
+   */
+  getByNoteIndex(noteIndex) {
+    return this.byNoteIndex.get(noteIndex);
+  }
+  /**
+   * 根据 configId (UUID) 获取索引项
+   */
+  getByConfigId(configId) {
+    const noteIndex = this.byConfigId.get(configId);
+    return noteIndex ? this.byNoteIndex.get(noteIndex) : void 0;
+  }
+  /**
+   * 检查 noteIndex 是否存在
+   */
+  has(noteIndex) {
+    return this.byNoteIndex.has(noteIndex);
+  }
+  /**
+   * 更新笔记配置
+   * @param noteIndex - 笔记索引
+   * @param configUpdates - 要更新的配置字段
+   */
+  updateConfig(noteIndex, configUpdates) {
+    const item = this.byNoteIndex.get(noteIndex);
+    if (!item) {
+      logger.warn(`\u5C1D\u8BD5\u66F4\u65B0\u4E0D\u5B58\u5728\u7684\u7B14\u8BB0: ${noteIndex}`);
+      return;
+    }
+    Object.assign(item.noteConfig, configUpdates);
+    item.noteConfig.updated_at = Date.now();
+    logger.debug(`\u66F4\u65B0\u7B14\u8BB0\u914D\u7F6E: ${noteIndex}`, configUpdates);
+  }
+  /**
+   * 删除笔记
+   * @param noteIndex - 笔记索引
+   */
+  delete(noteIndex) {
+    const item = this.byNoteIndex.get(noteIndex);
+    if (!item) {
+      logger.warn(`\u5C1D\u8BD5\u5220\u9664\u4E0D\u5B58\u5728\u7684\u7B14\u8BB0: ${noteIndex}`);
+      return;
+    }
+    this.byNoteIndex.delete(noteIndex);
+    this.byConfigId.delete(item.noteConfig.id);
+    logger.info(`\u5220\u9664\u7B14\u8BB0\u7D22\u5F15: ${noteIndex}`);
+  }
+  /**
+   * 添加新笔记
+   * @param note - 笔记信息
+   */
+  add(note) {
+    const item = {
+      noteIndex: note.index,
+      folderName: note.dirName,
+      noteConfig: note.config
+    };
+    this.byNoteIndex.set(note.index, item);
+    this.byConfigId.set(note.config.id, note.index);
+    logger.info(`\u6DFB\u52A0\u7B14\u8BB0\u7D22\u5F15: ${note.index}`);
+  }
+  /**
+   * 更新笔记的文件夹名称（标题变更时）
+   * @param noteIndex - 笔记索引
+   * @param newFolderName - 新的文件夹名称
+   */
+  updateFolderName(noteIndex, newFolderName) {
+    const item = this.byNoteIndex.get(noteIndex);
+    if (!item) {
+      logger.warn(`\u5C1D\u8BD5\u66F4\u65B0\u4E0D\u5B58\u5728\u7684\u7B14\u8BB0: ${noteIndex}`);
+      return;
+    }
+    item.folderName = newFolderName;
+    logger.debug(`\u66F4\u65B0\u7B14\u8BB0\u6587\u4EF6\u5939\u540D\u79F0: ${noteIndex} -> ${newFolderName}`);
+  }
+};
+
+// services/readme/service.ts
+import {
+  existsSync as existsSync5,
+  readFileSync as readFileSync3,
+  writeFileSync as writeFileSync2,
+  promises as fsPromises2
+} from "fs";
+var ReadmeService = class _ReadmeService {
+  constructor() {
+    this.noteManager = NoteManager.getInstance();
+    this.readmeGenerator = new ReadmeGenerator();
+    this.configManager = ConfigManager.getInstance();
+    this.noteIndexCache = NoteIndexCache.getInstance();
+  }
+  static getInstance() {
+    if (!_ReadmeService.instance) {
+      _ReadmeService.instance = new _ReadmeService();
+    }
+    return _ReadmeService.instance;
+  }
+  /**
+   * 更新所有笔记的 README
+   * @param options - 更新选项
+   */
+  async updateAllReadmes(options = {}) {
+    const {
+      updateSidebar = true,
+      updateHome = true,
+      notes: providedNotes
+    } = options;
+    logger.info("\u5F00\u59CB\u66F4\u65B0\u77E5\u8BC6\u5E93...");
+    const notes = providedNotes ?? this.noteManager.scanNotes();
+    logger.info(`\u626B\u63CF\u5230 ${notes.length} \u7BC7\u7B14\u8BB0`);
+    const changedIndexes = await this.getChangedNoteIndexes();
+    const shouldIncrementalUpdate = changedIndexes.size > 0 && changedIndexes.size < notes.length * 0.3;
+    let notesToUpdate = notes;
+    if (shouldIncrementalUpdate) {
+      notesToUpdate = notes.filter((note) => changedIndexes.has(note.index));
+      logger.info(
+        `\u68C0\u6D4B\u5230 ${changedIndexes.size} \u7BC7\u7B14\u8BB0\u6709\u53D8\u66F4\uFF0C\u4F7F\u7528\u589E\u91CF\u66F4\u65B0\u6A21\u5F0F`
+      );
+    } else {
+      logger.info("\u4F7F\u7528\u5168\u91CF\u66F4\u65B0\u6A21\u5F0F");
+    }
+    const startTime = Date.now();
+    await this.updateNoteReadmesInParallel(notesToUpdate);
+    const updateTime = Date.now() - startTime;
+    logger.info(`\u66F4\u65B0\u4E86 ${notesToUpdate.length} \u7BC7\u7B14\u8BB0 (\u8017\u65F6 ${updateTime}ms)`);
+    if (updateHome) {
+      await this.updateHomeReadme(notes);
+    }
+    if (updateSidebar) {
+      await this.updateSidebar(notes);
+    }
+    logger.info("\u77E5\u8BC6\u5E93\u66F4\u65B0\u5B8C\u6210\uFF01");
+  }
+  /**
+   * 只更新指定笔记的 README（不更新 sidebar、home）
+   * @param noteIndexes - 笔记索引数组，例如 ['0001', '0002']
+   */
+  async updateNoteReadmesOnly(noteIndexes) {
+    if (noteIndexes.length === 0) return;
+    const notesToUpdate = [];
+    for (const noteIndex of noteIndexes) {
+      const note = this.noteManager.getNoteByIndex(noteIndex);
+      if (note) {
+        notesToUpdate.push(note);
+      } else {
+        logger.warn(`\u7B14\u8BB0\u672A\u627E\u5230: ${noteIndex}`);
+      }
+    }
+    if (notesToUpdate.length === 0) {
+      logger.warn("\u6CA1\u6709\u627E\u5230\u9700\u8981\u66F4\u65B0\u7684\u7B14\u8BB0");
+      return;
+    }
+    for (const note of notesToUpdate) {
+      try {
+        this.readmeGenerator.updateNoteReadme(note);
+      } catch (error) {
+        logger.error(`\u66F4\u65B0\u7B14\u8BB0 ${note.dirName} \u5931\u8D25`, error);
+      }
+    }
+  }
+  /**
+   * 获取变更的笔记索引集合
+   * @returns 变更的笔记索引集合
+   */
+  async getChangedNoteIndexes() {
+    try {
+      return getChangedIds();
+    } catch (error) {
+      return /* @__PURE__ */ new Set();
+    }
+  }
+  /**
+   * 并行更新多个笔记的 README
+   * @param notes - 笔记信息数组
+   */
+  async updateNoteReadmesInParallel(notes) {
+    const batchSize = 10;
+    const batches = [];
+    for (let i = 0; i < notes.length; i += batchSize) {
+      batches.push(notes.slice(i, i + batchSize));
+    }
+    let successCount = 0;
+    let failCount = 0;
+    for (const batch of batches) {
+      const results = await Promise.allSettled(
+        batch.map(
+          (note) => Promise.resolve().then(() => {
+            this.readmeGenerator.updateNoteReadme(note);
+          })
+        )
+      );
+      for (const result of results) {
+        if (result.status === "fulfilled") {
+          successCount++;
+        } else {
+          failCount++;
+          logger.error("\u66F4\u65B0\u7B14\u8BB0\u5931\u8D25", result.reason);
+        }
+      }
+    }
+    if (failCount > 0) {
+      logger.warn(`\u66F4\u65B0\u5B8C\u6210\uFF1A\u6210\u529F ${successCount} \u7BC7\uFF0C\u5931\u8D25 ${failCount} \u7BC7`);
+    }
+  }
+  /**
+   * 更新侧边栏配置
+   * @param notes - 笔记信息数组
+   */
+  async updateSidebar(notes) {
+    if (!existsSync5(ROOT_README_PATH)) {
+      logger.error("\u672A\u627E\u5230\u9996\u9875 README\uFF0C\u65E0\u6CD5\u751F\u6210\u4FA7\u8FB9\u680F");
+      return;
+    }
+    const content = readFileSync3(ROOT_README_PATH, "utf-8");
+    const lines = content.split("\n");
+    const itemList = [];
+    const titles = [];
+    const titlesNotesCount = [];
+    let currentNoteCount = 0;
+    let inTocRegion = false;
+    for (const line of lines) {
+      if (line.includes("<!-- region:toc -->")) {
+        inTocRegion = true;
+        continue;
+      }
+      if (line.includes("<!-- endregion:toc -->")) {
+        inTocRegion = false;
+        continue;
+      }
+      if (inTocRegion) {
+        continue;
+      }
+      const parsed = parseNoteLine(line);
+      if (parsed.isMatch && parsed.noteIndex) {
+        const note = notes.find((n) => n.index === parsed.noteIndex);
+        if (!note) {
+          logger.warn(`\u672A\u627E\u5230\u7B14\u8BB0\u7D22\u5F15: ${parsed.noteIndex}`);
+          continue;
+        }
+        let statusEmoji = "\u23F0 ";
+        if (note?.config) {
+          if (note.config.done) {
+            statusEmoji = "\u2705 ";
+          }
+        }
+        const sidebarShowNoteId = this.configManager.get("sidebarShowNoteId");
+        let displayText = note.dirName;
+        if (!sidebarShowNoteId) {
+          displayText = note.dirName.replace(/^\d{4}\.\s/, "");
+        }
+        itemList.push({
+          text: statusEmoji + displayText,
+          link: `/notes/${note.dirName}/README`
+        });
+        currentNoteCount++;
+        continue;
+      }
+      const titleMatch = line.match(/^(#{2,})\s+(.+)$/);
+      if (titleMatch) {
+        if (titles.length > 0) {
+          titlesNotesCount.push(currentNoteCount);
+        }
+        titles.push(line);
+        currentNoteCount = 0;
+      }
+    }
+    if (titles.length > 0) {
+      titlesNotesCount.push(currentNoteCount);
+    }
+    const sidebarIsCollapsed = true;
+    const hierarchicalSidebar = genHierarchicalSidebar(
+      itemList,
+      titles,
+      titlesNotesCount,
+      sidebarIsCollapsed
+    );
+    writeFileSync2(
+      VP_SIDEBAR_PATH,
+      JSON.stringify(hierarchicalSidebar, null, 2),
+      "utf-8"
+    );
+    logger.info("\u5DF2\u66F4\u65B0\u4FA7\u8FB9\u680F\u914D\u7F6E");
+  }
+  /**
+   * 更新首页 README
+   * @param notes - 笔记信息数组
+   */
+  async updateHomeReadme(notes) {
+    this.readmeGenerator.updateHomeReadme(notes, ROOT_README_PATH);
+  }
+  /**
+   * 增量更新首页 README 中的单个笔记
+   * @param noteIndex - 笔记索引
+   * @param updates - 需要更新的配置字段
+   */
+  async updateNoteInReadme(noteIndex, updates) {
+    const item = this.noteIndexCache.getByNoteIndex(noteIndex);
+    if (!item) {
+      logger.warn(`\u5C1D\u8BD5\u66F4\u65B0\u4E0D\u5B58\u5728\u7684\u7B14\u8BB0: ${noteIndex}`);
+      return;
+    }
+    const content = await fsPromises2.readFile(ROOT_README_PATH, "utf-8");
+    const lines = content.split("\n");
+    const repoOwner = this.configManager.get("author");
+    const repoName = this.configManager.get("repoName");
+    const mergedConfig = { ...item.noteConfig, ...updates };
+    const tempNoteInfo = {
+      index: noteIndex,
+      dirName: item.folderName,
+      path: "",
+      readmePath: "",
+      configPath: "",
+      config: mergedConfig
+    };
+    let updated = false;
+    for (let i = 0; i < lines.length; i++) {
+      const parsed = parseNoteLine(lines[i]);
+      if (parsed.noteIndex === noteIndex) {
+        lines[i] = buildNoteLineMarkdown(tempNoteInfo, repoOwner, repoName);
+        updated = true;
+      }
+    }
+    if (updated) {
+      await fsPromises2.writeFile(ROOT_README_PATH, lines.join("\n"), "utf-8");
+      logger.info(`\u589E\u91CF\u66F4\u65B0 README.md \u4E2D\u7684\u7B14\u8BB0: ${noteIndex}`);
+    } else {
+      logger.warn(`README.md \u4E2D\u672A\u627E\u5230\u7B14\u8BB0: ${noteIndex}`);
+    }
+  }
+  /**
+   * 从首页 README 中删除笔记
+   * @param noteIndex - 笔记索引
+   */
+  async deleteNoteFromReadme(noteIndex) {
+    const content = await fsPromises2.readFile(ROOT_README_PATH, "utf-8");
+    const lines = content.split("\n");
+    const linesToRemove = [];
+    for (let i = 0; i < lines.length; i++) {
+      const parsed = parseNoteLine(lines[i]);
+      if (parsed.noteIndex === noteIndex) {
+        linesToRemove.push(i);
+      }
+    }
+    if (linesToRemove.length > 0) {
+      for (let i = linesToRemove.length - 1; i >= 0; i--) {
+        lines.splice(linesToRemove[i], 1);
+      }
+      await fsPromises2.writeFile(ROOT_README_PATH, lines.join("\n"), "utf-8");
+      logger.info(
+        `\u4ECE README.md \u4E2D\u5220\u9664\u7B14\u8BB0: ${noteIndex} (${linesToRemove.length} \u5904\u5F15\u7528)`
+      );
+    } else {
+      logger.warn(`README.md \u4E2D\u672A\u627E\u5230\u7B14\u8BB0: ${noteIndex}`);
+    }
+  }
+  /**
+   * 在首页 README 末尾添加新笔记
+   * @param noteIndex - 笔记索引
+   */
+  async appendNoteToReadme(noteIndex) {
+    const item = this.noteIndexCache.getByNoteIndex(noteIndex);
+    if (!item) {
+      logger.warn(`\u5C1D\u8BD5\u6DFB\u52A0\u4E0D\u5B58\u5728\u7684\u7B14\u8BB0: ${noteIndex}`);
+      return;
+    }
+    const content = await fsPromises2.readFile(ROOT_README_PATH, "utf-8");
+    const lines = content.split("\n");
+    const repoOwner = this.configManager.get("author");
+    const repoName = this.configManager.get("repoName");
+    const tempNoteInfo = {
+      index: noteIndex,
+      dirName: item.folderName,
+      path: "",
+      readmePath: "",
+      configPath: "",
+      config: item.noteConfig
+    };
+    const noteLine = buildNoteLineMarkdown(tempNoteInfo, repoOwner, repoName);
+    lines.push(noteLine);
+    await fsPromises2.writeFile(ROOT_README_PATH, lines.join("\n"), "utf-8");
+    logger.info(`\u5728 README.md \u672B\u5C3E\u6DFB\u52A0\u7B14\u8BB0: ${noteIndex}`);
+  }
+  /**
+   * 重新生成 sidebar.json（基于当前 README.md）
+   * @param notes - 可选的笔记列表，不传则内部扫描
+   */
+  async regenerateSidebar(notes) {
+    const allNotes = notes ?? (this.noteIndexCache.isInitialized() ? this.noteIndexCache.toNoteInfoList() : this.noteManager.scanNotes());
+    await this.updateSidebar(allNotes);
+    logger.info("\u91CD\u65B0\u751F\u6210 sidebar.json");
+  }
+};
+
+// services/note/service.ts
+import { writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
+import { join as join6 } from "path";
+import { v4 as uuidv4 } from "uuid";
+
+// config/templates.ts
+function generateNoteTitle(noteIndex, title, repoUrl) {
+  const dirName = `${noteIndex}. ${title}`;
+  const encodedDirName = encodeURIComponent(dirName);
+  return `# [${dirName}](${repoUrl}/${encodedDirName})`;
+}
+
+// services/note/service.ts
+var NEW_NOTES_README_MD_TEMPLATE = `
+<!-- region:toc -->
+
+- [1. \u{1F3AF} \u672C\u8282\u5185\u5BB9](#1--\u672C\u8282\u5185\u5BB9)
+- [2. \u{1FAE7} \u8BC4\u4EF7](#2--\u8BC4\u4EF7)
+
+<!-- endregion:toc -->
+
+## 1. \u{1F3AF} \u672C\u8282\u5185\u5BB9
+
+- todo
+
+## 2. \u{1FAE7} \u8BC4\u4EF7
+
+- todo
+`;
+var NoteService = class _NoteService {
+  constructor() {
+    this.ignoredConfigPaths = /* @__PURE__ */ new Set();
+    this.noteManager = NoteManager.getInstance();
+    this.noteIndexCache = NoteIndexCache.getInstance();
+  }
+  static getInstance() {
+    if (!_NoteService.instance) {
+      _NoteService.instance = new _NoteService();
+    }
+    return _NoteService.instance;
+  }
+  /**
+   * 标记配置文件在下次变更时被忽略（防止 API 写入触发文件监听循环）
+   * @param configPath - 配置文件路径
+   */
+  ignoreNextConfigChange(configPath) {
+    this.ignoredConfigPaths.add(configPath);
+  }
+  /**
+   * 检查配置文件是否应该被忽略
+   * @param configPath - 配置文件路径
+   * @returns 是否应该忽略
+   */
+  shouldIgnoreConfigChange(configPath) {
+    if (this.ignoredConfigPaths.has(configPath)) {
+      this.ignoredConfigPaths.delete(configPath);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * 获取所有笔记
+   * dev 模式下（缓存已初始化）从内存读取，其他模式回退到文件扫描
+   * @returns 笔记信息数组
+   */
+  getAllNotes() {
+    if (this.noteIndexCache.isInitialized()) {
+      return this.noteIndexCache.toNoteInfoList();
+    }
+    return this.noteManager.scanNotes();
+  }
+  /**
+   * 获取笔记（通过索引）
+   * @param noteIndex - 笔记索引（文件夹前 4 位数字）
+   * @returns 笔记信息，未找到时返回 undefined
+   */
+  getNoteByIndex(noteIndex) {
+    return this.noteManager.getNoteByIndex(noteIndex);
+  }
+  /**
+   * 创建新笔记
+   * @param options - 创建选项
+   * @returns 新创建的笔记信息
+   */
+  async createNote(options = {}) {
+    const {
+      title = "new",
+      category,
+      enableDiscussions = false,
+      configId,
+      usedIndexes
+    } = options;
+    const noteIndex = this.generateNextNoteIndex(usedIndexes);
+    const dirName = `${noteIndex}. ${title}`;
+    const notePath = join6(NOTES_PATH, dirName);
+    await ensureDirectory(notePath);
+    const readmePath = join6(notePath, "README.md");
+    const noteTitle = generateNoteTitle(noteIndex, title, REPO_NOTES_URL);
+    const readmeContent = noteTitle + "\n" + NEW_NOTES_README_MD_TEMPLATE;
+    writeFileSync3(readmePath, readmeContent, "utf-8");
+    const configPath = join6(notePath, ".tnotes.json");
+    const now = Date.now();
+    const config = {
+      id: configId || uuidv4(),
+      // 配置 ID 使用 UUID（跨知识库唯一）
+      bilibili: [],
+      tnotes: [],
+      yuque: [],
+      done: false,
+      category,
+      enableDiscussions,
+      created_at: now,
+      updated_at: now
+    };
+    this.noteManager.writeNoteConfig(configPath, config);
+    logger.info(`Created new note: ${dirName}`);
+    return {
+      index: noteIndex,
+      // 返回的 id 是笔记索引（目录前缀）
+      path: notePath,
+      dirName,
+      readmePath,
+      configPath,
+      config
+    };
+  }
+  /**
+   * 生成下一个笔记索引（填充空缺）
+   * @param usedIndexes - 可选的已使用编号集合，不传则内部扫描
+   * @returns 新的笔记索引（4位数字字符串，从 0001 到 9999）
+   */
+  generateNextNoteIndex(usedIndexes) {
+    if (!usedIndexes) {
+      const notes = this.getAllNotes();
+      usedIndexes = /* @__PURE__ */ new Set();
+      for (const note of notes) {
+        const id = parseInt(note.index, 10);
+        if (!isNaN(id) && id >= 1 && id <= 9999) {
+          usedIndexes.add(id);
+        }
+      }
+    }
+    if (usedIndexes.size === 0) {
+      return "0001";
+    }
+    for (let i = 1; i <= 9999; i++) {
+      if (!usedIndexes.has(i)) {
+        return i.toString().padStart(CONSTANTS.NOTE_INDEX_LENGTH, "0");
+      }
+    }
+    throw new Error("\u6240\u6709\u7B14\u8BB0\u7F16\u53F7 (0001-9999) \u5DF2\u88AB\u5360\u7528\uFF0C\u65E0\u6CD5\u521B\u5EFA\u65B0\u7B14\u8BB0");
+  }
+  /**
+   * 更新笔记配置
+   * @param noteIndex - 笔记索引
+   * @param updates - 配置更新
+   */
+  async updateNoteConfig(noteIndex, updates) {
+    const note = this.getNoteByIndex(noteIndex);
+    if (!note || !note.config) {
+      throw new Error(`Note not found or no config: ${noteIndex}`);
+    }
+    const oldConfig = { ...note.config };
+    const updatedConfig = {
+      ...note.config,
+      ...updates,
+      updated_at: Date.now()
+    };
+    this.ignoreNextConfigChange(note.configPath);
+    this.noteManager.updateNoteConfig(note, updatedConfig);
+    this.noteIndexCache.updateConfig(noteIndex, updatedConfig);
+    const needsGlobalUpdate = this.checkNeedsGlobalUpdate(
+      oldConfig,
+      updatedConfig
+    );
+    if (needsGlobalUpdate) {
+      logger.info(`\u68C0\u6D4B\u5230\u5168\u5C40\u5B57\u6BB5\u53D8\u66F4 (${noteIndex})\uFF0C\u6B63\u5728\u589E\u91CF\u66F4\u65B0\u5168\u5C40\u6587\u4EF6...`);
+      const readmeService = ReadmeService.getInstance();
+      await readmeService.updateNoteInReadme(noteIndex, updates);
+      await readmeService.regenerateSidebar();
+      logger.info(`\u5168\u5C40\u6587\u4EF6\u589E\u91CF\u66F4\u65B0\u5B8C\u6210 (${noteIndex})`);
+    } else {
+      logger.debug(`\u914D\u7F6E\u66F4\u65B0\u4E0D\u5F71\u54CD\u5168\u5C40\u6587\u4EF6 (${noteIndex})`);
+    }
+  }
+  /**
+   * 检查配置更新是否需要触发全局更新
+   * @param oldConfig - 旧配置
+   * @param newConfig - 新配置
+   * @returns 是否需要全局更新
+   */
+  checkNeedsGlobalUpdate(oldConfig, newConfig) {
+    const globalFields = ["done"];
+    for (const field of globalFields) {
+      if (oldConfig[field] !== newConfig[field]) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * 修正笔记标题
+   * @param noteInfo - 笔记信息
+   * @returns 是否进行了修正
+   */
+  async fixNoteTitle(noteInfo) {
+    try {
+      const readmeContent = readFileSync4(noteInfo.readmePath, "utf-8");
+      if (readmeContent.length === 0) return false;
+      const lines = readmeContent.split("\n");
+      const match = noteInfo.dirName.match(/^\d{4}\.\s+(.+)$/);
+      if (!match) {
+        logger.warn(`\u68C0\u6D4B\u5230\u9519\u8BEF\u7684\u7B14\u8BB0\u76EE\u5F55\u540D\u79F0\uFF1A${noteInfo.dirName}`);
+        return false;
+      }
+      const expectedTitle = match[1];
+      const expectedH1 = generateNoteTitle(
+        noteInfo.index,
+        expectedTitle,
+        REPO_NOTES_URL
+      );
+      const firstLine = lines[0].trim();
+      if (!firstLine.startsWith("# ")) {
+        lines.unshift(expectedH1);
+        writeFileSync3(noteInfo.readmePath, lines.join("\n"), "utf-8");
+        logger.info(`Added title to: ${noteInfo.dirName}`);
+        return true;
+      }
+      if (firstLine !== expectedH1) {
+        lines[0] = expectedH1;
+        writeFileSync3(noteInfo.readmePath, lines.join("\n"), "utf-8");
+        logger.info(`Fixed title for: ${noteInfo.dirName}`);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      logger.error(`Failed to fix title for: ${noteInfo.dirName}`, error);
+      return false;
+    }
+  }
+  /**
+   * 修正所有笔记的标题
+   * @param providedNotes - 可选的笔记列表，不传则内部扫描
+   * @returns 修正的笔记数量
+   */
+  async fixAllNoteTitles(providedNotes) {
+    const notes = providedNotes ?? this.getAllNotes();
+    let fixedCount = 0;
+    for (const note of notes) {
+      const fixed = await this.fixNoteTitle(note);
+      if (fixed) {
+        fixedCount++;
+      }
+    }
+    if (fixedCount > 0) {
+      logger.info(`Fixed ${fixedCount} note titles`);
+    }
+    return fixedCount;
+  }
+};
+
+// services/file-watcher/service.ts
+var NOTES_DIR_NOT_SET_ERROR = "NOTES_DIR_PATH \u672A\u8BBE\u7F6E\uFF0C\u65E0\u6CD5\u542F\u52A8\u6587\u4EF6\u76D1\u542C";
+var UPDATE_UNLOCK_DELAY_MS2 = 500;
+var FileWatcherService = class {
+  constructor(notesDir = NOTES_DIR_PATH) {
+    this.notesDir = notesDir;
+    this.unlockTimer = null;
+    if (!this.notesDir) {
+      throw new Error(NOTES_DIR_NOT_SET_ERROR);
+    }
+    this.init();
+  }
+  init() {
+    this.noteService = NoteService.getInstance();
+    this.readmeService = ReadmeService.getInstance();
+    this.noteIndexCache = NoteIndexCache.getInstance();
+    this.watchState = this.initWatchState();
+    this.scheduler = this.initScheduler();
+    this.folderHandler = this.initFolderHandler();
+    this.renameDetector = this.initRenameDetector();
+    this.configHandler = this.initConfigHandler();
+    this.readmeHandler = this.initReadmeHandler();
+    this.coordinator = this.initCoordinator();
+    this.adapter = this.initAdapter();
+  }
+  initWatchState() {
+    const watchState = new WatchState({ notesDir: this.notesDir, logger });
+    watchState.initializeFromDisk();
+    return watchState;
+  }
+  initScheduler() {
+    return new EventScheduler({
+      onFlush: (events) => this.handleFileChange(events),
+      onPauseForBatch: () => logger.warn("\u76D1\u542C\u670D\u52A1\u6682\u505C 3s \u7B49\u5F85\u6279\u91CF\u66F4\u65B0\u5B8C\u6210..."),
+      onResumeAfterBatch: () => logger.info("\u6062\u590D\u81EA\u52A8\u76D1\u542C"),
+      reinit: () => this.watchState.initializeFromDisk()
+    });
+  }
+  initFolderHandler() {
+    return new FolderChangeHandler({
+      notesDir: this.notesDir,
+      watchState: this.watchState,
+      scheduler: this.scheduler,
+      noteService: this.noteService,
+      readmeService: this.readmeService,
+      noteIndexCache: this.noteIndexCache,
+      logger
+    });
+  }
+  initRenameDetector() {
+    return new RenameDetector({
+      notesDir: this.notesDir,
+      dirCache: {
+        has: (name) => this.watchState.hasNoteDir(name),
+        add: (name) => this.watchState.addNoteDir(name),
+        delete: (name) => this.watchState.deleteNoteDir(name)
+      },
+      logger,
+      onDelete: (oldName) => this.folderHandler.handleFolderDeletion(oldName),
+      onRename: (oldName, newName) => this.folderHandler.handleFolderRenameUpdate(oldName, newName)
+    });
+  }
+  initConfigHandler() {
+    return new ConfigChangeHandler({
+      state: this.watchState,
+      noteService: this.noteService,
+      noteIndexCache: this.noteIndexCache,
+      logger
+    });
+  }
+  initReadmeHandler() {
+    return new ReadmeChangeHandler({ noteService: this.noteService });
+  }
+  initCoordinator() {
+    return new GlobalUpdateCoordinator({
+      readmeService: this.readmeService,
+      noteIndexCache: this.noteIndexCache,
+      logger
+    });
+  }
+  initAdapter() {
+    return new FsWatcherAdapter({
+      notesDir: this.notesDir,
+      isUpdating: () => this.scheduler.getUpdating(),
+      onRename: (folderName) => this.renameDetector.handleFsRename(folderName),
+      onNoteEvent: (event) => this.onNoteEvent(event),
+      logger
+    });
+  }
+  start() {
+    this.watchState.initializeFromDisk();
+    this.adapter.start();
+  }
+  stop() {
+    this.adapter.stop();
+    this.scheduler.clearTimers();
+    this.renameDetector.clearTimers();
+    this.folderHandler.clearTimers();
+    if (this.unlockTimer) {
+      clearTimeout(this.unlockTimer);
+      this.unlockTimer = null;
+    }
+    logger.info("\u6587\u4EF6\u76D1\u542C\u670D\u52A1\u5DF2\u505C\u6B62");
+  }
+  pause() {
+    this.scheduler.setUpdating(true);
+    logger.info("\u6587\u4EF6\u76D1\u542C\u5DF2\u6682\u505C");
+  }
+  resume() {
+    this.watchState.initializeFromDisk();
+    this.scheduler.setUpdating(false);
+    logger.info("\u6587\u4EF6\u76D1\u542C\u5DF2\u6062\u590D");
+  }
+  isWatching() {
+    return this.adapter.isWatching();
+  }
+  // #region - 私有实现
+  onNoteEvent(event) {
+    if (!this.isNoteFile(event.path)) return;
+    if (!this.watchState.updateFileHash(event.path)) return;
+    if (this.scheduler.recordChangeAndDetectBatch()) return;
+    this.scheduler.enqueue(event);
+  }
+  async handleFileChange(events) {
+    try {
+      const configChanges = events.filter(
+        (e) => e.type === WATCH_EVENT_TYPES.CONFIG
+      );
+      const readmeChanges = events.filter(
+        (e) => e.type === WATCH_EVENT_TYPES.README
+      );
+      const changedNoteIndexes = await this.configHandler.handle(configChanges);
+      if (changedNoteIndexes.length > 0) {
+        await safeExecute(
+          "\u914D\u7F6E\u53D8\u66F4\u66F4\u65B0",
+          () => this.coordinator.applyConfigUpdates(changedNoteIndexes),
+          logger
+        );
+        return;
+      }
+      await safeExecute(
+        "README \u53D8\u66F4\u66F4\u65B0",
+        async () => {
+          await this.readmeHandler.handle(readmeChanges);
+          await this.coordinator.updateNoteReadmesOnly(events);
+        },
+        logger
+      );
+    } finally {
+      if (this.unlockTimer) clearTimeout(this.unlockTimer);
+      this.unlockTimer = setTimeout(() => {
+        this.unlockTimer = null;
+        this.scheduler.setUpdating(false);
+      }, UPDATE_UNLOCK_DELAY_MS2);
+    }
+  }
+  isNoteFile(filePath) {
+    return filePath.endsWith("README.md") || filePath.endsWith(".tnotes.json");
+  }
+  // #endregion - 私有实现
+};
+
+// core/GitManager.ts
+import { resolve } from "path";
+import { existsSync as existsSync6 } from "fs";
+var GitManager = class {
+  constructor(dir, logger2) {
+    this.dir = dir;
+    this.logger = logger2?.child("git") || new Logger({ prefix: "git" });
+  }
+  /**
+   * 检查是否为有效的 Git 仓库
+   */
+  async isValidRepo() {
+    try {
+      const result = await runCommand(
+        "git rev-parse --is-inside-work-tree",
+        this.dir
+      );
+      return result.trim() === "true";
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 确保是有效的 Git 仓库，否则抛出错误
+   */
+  async ensureValidRepo() {
+    if (!await this.isValidRepo()) {
+      throw createError.gitNotRepo(this.dir);
+    }
+  }
+  /**
+   * 获取 Git 状态
+   */
+  async getStatus() {
+    await this.ensureValidRepo();
+    const statusOutput = await runCommand(
+      "git -c core.quotePath=false status --porcelain",
+      this.dir
+    );
+    const lines = statusOutput.trim().split("\n").filter((line) => line);
+    const files = lines.map((line) => {
+      const statusCode = line.substring(0, 2);
+      let path = line.substring(3);
+      path = path.replace(/^"(.*)"$/, "$1");
+      let status = "modified";
+      if (line.startsWith("??")) {
+        status = "untracked";
+      } else if (/^[MADRC]/.test(statusCode)) {
+        status = "staged";
+      } else if (/^.[MD]/.test(statusCode)) {
+        status = "unstaged";
+      }
+      return { path, status, statusCode };
+    });
+    const staged = files.filter((f) => f.status === "staged").length;
+    const unstaged = files.filter((f) => f.status === "unstaged").length;
+    const untracked = files.filter((f) => f.status === "untracked").length;
+    const branch = await runCommand("git branch --show-current", this.dir);
+    let ahead = 0;
+    let behind = 0;
+    try {
+      const aheadBehind = await runCommand(
+        "git rev-list --left-right --count @{upstream}...HEAD",
+        this.dir
+      );
+      const [behindStr, aheadStr] = aheadBehind.trim().split("	");
+      behind = parseInt(behindStr) || 0;
+      ahead = parseInt(aheadStr) || 0;
+    } catch {
+    }
+    return {
+      hasChanges: lines.length > 0,
+      changedFiles: lines.length,
+      staged,
+      unstaged,
+      untracked,
+      branch: branch.trim(),
+      ahead,
+      behind,
+      files
+    };
+  }
+  /**
+   * 获取远程仓库信息
+   */
+  async getRemoteInfo() {
+    try {
+      await this.ensureValidRepo();
+      const remoteUrl = await runCommand(
+        "git config --get remote.origin.url",
+        this.dir
+      );
+      const url = remoteUrl.trim();
+      if (!url) return null;
+      const httpsMatch = url.match(
+        /https:\/\/(?:www\.)?github\.com\/([^/]+)\/(.+?)(?:\.git)?$/
+      );
+      if (httpsMatch) {
+        return {
+          url,
+          type: "https",
+          owner: httpsMatch[1],
+          repo: httpsMatch[2]
+        };
+      }
+      const sshMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(?:\.git)?$/);
+      if (sshMatch) {
+        return {
+          url,
+          type: "ssh",
+          owner: sshMatch[1],
+          repo: sshMatch[2]
+        };
+      }
+      return { url, type: "unknown" };
+    } catch {
+      return null;
+    }
+  }
+  /**
+   * 检查是否有未提交的更改
+   */
+  async hasUncommittedChanges() {
+    const status = await this.getStatus();
+    return status.hasChanges;
+  }
+  /**
+   * Stash 当前更改
+   */
+  async stash(message) {
+    try {
+      await this.ensureValidRepo();
+      const cmd = message ? `git stash push -m "${message}"` : "git stash push";
+      await runCommand(cmd, this.dir);
+      this.logger.info("Stashed uncommitted changes");
+      return true;
+    } catch (error) {
+      this.logger.warn("Failed to stash changes");
+      return false;
+    }
+  }
+  /**
+   * Pop stash
+   */
+  async stashPop() {
+    try {
+      await this.ensureValidRepo();
+      await runCommand("git stash pop", this.dir);
+      this.logger.info("Restored stashed changes");
+      return true;
+    } catch (error) {
+      this.logger.warn("Failed to restore stashed changes");
+      return false;
+    }
+  }
+  /**
+   * 拉取远程更新
+   */
+  async pull(options) {
+    await this.ensureValidRepo();
+    const { rebase = true, autostash = true } = options || {};
+    const hasChanges = await this.hasUncommittedChanges();
+    let didStash = false;
+    if (hasChanges && !autostash) {
+      this.logger.warn("Repository has uncommitted changes");
+      didStash = await this.stash("Auto-stash before pull");
+    }
+    try {
+      const status = await this.getStatus();
+      const beforeCommit = await runCommand("git rev-parse HEAD", this.dir);
+      this.logger.info("\u6B63\u5728\u62C9\u53D6\u8FDC\u7A0B\u66F4\u65B0...");
+      const cmd = `git pull ${rebase ? "--rebase" : ""} ${autostash ? "--autostash" : ""}`.trim();
+      await runCommand(cmd, this.dir);
+      const afterCommit = await runCommand("git rev-parse HEAD", this.dir);
+      if (beforeCommit.trim() !== afterCommit.trim()) {
+        try {
+          const diffOutput = await runCommand(
+            `git diff --name-only ${beforeCommit.trim()}..${afterCommit.trim()}`,
+            this.dir
+          );
+          const changedFiles = diffOutput.trim().split("\n").filter((f) => f);
+          if (changedFiles.length > 0) {
+            console.log(`  \u66F4\u65B0\u4E86 ${changedFiles.length} \u4E2A\u6587\u4EF6:`);
+            changedFiles.forEach((file, index) => {
+              console.log(`  ${index + 1}. ${file}`);
+            });
+          }
+          this.logger.success(`\u62C9\u53D6\u6210\u529F: ${changedFiles.length} \u4E2A\u6587\u4EF6\u5DF2\u66F4\u65B0`);
+        } catch {
+          this.logger.success("\u62C9\u53D6\u6210\u529F");
+        }
+      } else {
+        this.logger.info("\u5DF2\u662F\u6700\u65B0\uFF0C\u6CA1\u6709\u9700\u8981\u62C9\u53D6\u7684\u66F4\u65B0");
+      }
+      await this.updateSubmodules();
+    } catch (error) {
+      this.logger.error("\u62C9\u53D6\u5931\u8D25");
+      handleError(error);
+      throw error;
+    } finally {
+      if (didStash) {
+        await this.stashPop();
+      }
+    }
+  }
+  /**
+   * 提交更改
+   */
+  async commit(message) {
+    await this.ensureValidRepo();
+    try {
+      await runCommand(`git commit -m "${message}"`, this.dir);
+      this.logger.success(`Committed: ${message}`);
+    } catch (error) {
+      handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * 添加文件到暂存区
+   */
+  async add(files = ".") {
+    await this.ensureValidRepo();
+    const fileList = Array.isArray(files) ? files.join(" ") : files;
+    try {
+      await runCommand(`git add ${fileList}`, this.dir);
+      this.logger.info(`Staged changes: ${fileList}`);
+    } catch (error) {
+      handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * 推送到远程仓库
+   */
+  async push(options) {
+    await this.ensureValidRepo();
+    const { force = false, setUpstream = false } = options || {};
+    try {
+      const status = await this.getStatus();
+      this.logger.progress(`\u6B63\u5728\u63A8\u9001\u5230\u8FDC\u7A0B (${status.branch})...`);
+      let cmd = "git push";
+      if (force) cmd += " --force";
+      if (setUpstream) cmd += ` --set-upstream origin ${status.branch}`;
+      await runCommand(cmd, this.dir);
+      const remoteInfo = await this.getRemoteInfo();
+      if (remoteInfo) {
+        this.logger.success(`\u63A8\u9001\u6210\u529F \u2192 ${remoteInfo.owner}/${remoteInfo.repo}`);
+      } else {
+        this.logger.success("\u63A8\u9001\u6210\u529F");
+      }
+    } catch (error) {
+      this.logger.error("\u63A8\u9001\u5931\u8D25");
+      handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * 完整的推送流程：检查 -> 添加 -> 提交 -> 推送
+   */
+  async pushWithCommit(commitMessage, options) {
+    await this.ensureValidRepo();
+    const status = await this.getStatus();
+    if (!status.hasChanges) {
+      this.logger.info("\u6CA1\u6709\u9700\u8981\u63D0\u4EA4\u7684\u66F4\u6539");
+      return;
+    }
+    try {
+      await this.pushSubmodules(commitMessage);
+      const latestStatus = await this.getStatus();
+      if (!latestStatus.hasChanges) {
+        this.logger.info("\u6CA1\u6709\u9700\u8981\u63D0\u4EA4\u7684\u66F4\u6539");
+        return;
+      }
+      this.logger.info(`\u6B63\u5728\u63A8\u9001 ${latestStatus.changedFiles} \u4E2A\u6587\u4EF6...`);
+      latestStatus.files.forEach((file, index) => {
+        console.log(`  ${index + 1}. ${file.path}`);
+      });
+      await runCommand("git add .", this.dir);
+      const message = commitMessage || `update: ${latestStatus.changedFiles} files modified`;
+      await runCommand(`git commit -m "${message}"`, this.dir);
+      let cmd = "git push";
+      if (options?.force) cmd += " --force";
+      await runCommand(cmd, this.dir);
+      const remoteInfo = await this.getRemoteInfo();
+      if (remoteInfo) {
+        this.logger.success(
+          `\u63A8\u9001\u6210\u529F: ${latestStatus.changedFiles} \u4E2A\u6587\u4EF6 \u2192 https://github.com/${remoteInfo.owner}/${remoteInfo.repo}`
+        );
+      } else {
+        this.logger.success(`\u63A8\u9001\u6210\u529F: ${latestStatus.changedFiles} \u4E2A\u6587\u4EF6`);
+      }
+    } catch (error) {
+      this.logger.error(`\u63A8\u9001\u5931\u8D25`);
+      handleError(error);
+      throw error;
+    }
+  }
+  /**
+   * 完整的同步流程：拉取 -> 推送
+   */
+  async sync(options) {
+    const { commitMessage, rebase = true } = options || {};
+    try {
+      await this.pull({ rebase, autostash: true });
+      await this.pushWithCommit(commitMessage);
+    } catch (error) {
+      this.logger.error("Sync failed");
+      handleError(error);
+      throw error;
+    }
+  }
+  // ==================== Submodule 操作 ====================
+  /**
+   * 检查仓库是否包含 submodule
+   */
+  hasSubmodules() {
+    return existsSync6(resolve(this.dir, ".gitmodules"));
+  }
+  /**
+   * 获取所有 submodule 的路径
+   */
+  async getSubmodulePaths() {
+    if (!this.hasSubmodules()) return [];
+    try {
+      const output = await runCommand(
+        "git config --file .gitmodules --get-regexp path",
+        this.dir
+      );
+      return output.trim().split("\n").filter((line) => line).map((line) => line.replace(/^submodule\..*\.path\s+/, ""));
+    } catch {
+      return [];
+    }
+  }
+  /**
+   * 推送前处理 submodule：检查未提交/未推送的更改，自动提交并推送
+   */
+  async pushSubmodules(commitMessage) {
+    const paths = await this.getSubmodulePaths();
+    if (paths.length === 0) return;
+    for (const subPath of paths) {
+      const absPath = resolve(this.dir, subPath);
+      let hasChanges = false;
+      try {
+        const status = await runCommand("git status --porcelain", absPath);
+        hasChanges = status.trim().length > 0;
+      } catch {
+        continue;
+      }
+      if (hasChanges) {
+        const message = commitMessage || "update";
+        this.logger.info(`Submodule [${subPath}] \u6709\u672A\u63D0\u4EA4\u7684\u66F4\u6539\uFF0C\u6B63\u5728\u63D0\u4EA4...`);
+        await runCommand("git add -A", absPath);
+        await runCommand(`git commit -m "${message}"`, absPath);
+      }
+      let unpushed = 0;
+      try {
+        const output = await runCommand(
+          "git rev-list @{u}..HEAD --count",
+          absPath
+        );
+        unpushed = parseInt(output.trim()) || 0;
+      } catch {
+        unpushed = 1;
+      }
+      if (unpushed > 0) {
+        this.logger.info(
+          `Submodule [${subPath}] \u6709 ${unpushed} \u4E2A\u672A\u63A8\u9001\u7684\u63D0\u4EA4\uFF0C\u6B63\u5728\u63A8\u9001...`
+        );
+        await runCommand("git push", absPath);
+        this.logger.success(`Submodule [${subPath}] \u63A8\u9001\u6210\u529F`);
+      }
+    }
+  }
+  /**
+   * 拉取后更新 submodule 到父仓库指针指向的 commit
+   */
+  async updateSubmodules() {
+    if (!this.hasSubmodules()) return;
+    try {
+      this.logger.info("\u6B63\u5728\u66F4\u65B0 submodule...");
+      await runCommand("git submodule update --init", this.dir);
+      this.logger.success("Submodule \u5DF2\u540C\u6B65\u5230\u6700\u65B0\u6307\u9488");
+    } catch (error) {
+      this.logger.warn(
+        "Submodule \u66F4\u65B0\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6267\u884C git submodule update --init"
+      );
+    }
+  }
+  /**
+   * 显示状态摘要
+   */
+  async showStatus(options) {
+    const { showFiles = true } = options || {};
+    const status = await this.getStatus();
+    const remoteInfo = await this.getRemoteInfo();
+    console.log("\n\u{1F4CA} Git \u72B6\u6001:");
+    console.log(`  \u5206\u652F: ${status.branch}`);
+    if (remoteInfo) {
+      console.log(
+        `  \u8FDC\u7A0B: ${remoteInfo.owner}/${remoteInfo.repo} (${remoteInfo.type})`
+      );
+    }
+    if (status.hasChanges) {
+      console.log(
+        `  \u53D8\u66F4: ${status.changedFiles} \u4E2A\u6587\u4EF6 (\u5DF2\u6682\u5B58 ${status.staged}, \u672A\u6682\u5B58 ${status.unstaged}, \u672A\u8DDF\u8E2A ${status.untracked})`
+      );
+      if (showFiles && status.files.length > 0) {
+        console.log("  \u53D8\u66F4\u6587\u4EF6\u5217\u8868:");
+        const stagedFiles = status.files.filter((f) => f.status === "staged");
+        const unstagedFiles = status.files.filter(
+          (f) => f.status === "unstaged"
+        );
+        const untrackedFiles = status.files.filter(
+          (f) => f.status === "untracked"
+        );
+        if (stagedFiles.length > 0) {
+          console.log("    \u5DF2\u6682\u5B58:");
+          stagedFiles.forEach((f) => console.log(`      \u2713 ${f.path}`));
+        }
+        if (unstagedFiles.length > 0) {
+          console.log("    \u672A\u6682\u5B58:");
+          unstagedFiles.forEach((f) => console.log(`      \u2022 ${f.path}`));
+        }
+        if (untrackedFiles.length > 0) {
+          console.log("    \u672A\u8DDF\u8E2A:");
+          untrackedFiles.forEach((f) => console.log(`      ? ${f.path}`));
+        }
+      }
+    } else {
+      console.log("  \u72B6\u6001: \u5DE5\u4F5C\u533A\u5E72\u51C0\uFF0C\u6CA1\u6709\u53D8\u66F4");
+    }
+    if (status.ahead > 0 || status.behind > 0) {
+      const syncInfo = [];
+      if (status.ahead > 0) syncInfo.push(`\u9886\u5148 ${status.ahead} \u4E2A\u63D0\u4EA4`);
+      if (status.behind > 0) syncInfo.push(`\u843D\u540E ${status.behind} \u4E2A\u63D0\u4EA4`);
+      console.log(`  \u540C\u6B65: ${syncInfo.join(", ")}`);
+    }
+    console.log();
+  }
+};
+
+// core/ProcessManager.ts
+import { spawn } from "child_process";
+var ProcessManager = class {
+  constructor() {
+    this.processes = /* @__PURE__ */ new Map();
+    this.logger = new Logger({ prefix: "process" });
+    process.on("exit", () => {
+      this.killAll();
+    });
+    process.on("SIGINT", () => {
+      this.killAll();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      this.killAll();
+      process.exit(0);
+    });
+  }
+  /**
+   * 启动进程
+   * @param id - 进程ID
+   * @param command - 命令
+   * @param args - 参数列表
+   * @param options - spawn 选项
+   * @returns ProcessInfo
+   */
+  spawn(id, command, args = [], options) {
+    if (this.processes.has(id)) {
+      this.logger.warn(`\u8FDB\u7A0B ${id} \u5DF2\u5B58\u5728\uFF0C\u5148\u505C\u6B62\u65E7\u8FDB\u7A0B`);
+      this.kill(id);
+    }
+    const proc = spawn(command, args, {
+      stdio: "inherit",
+      shell: true,
+      ...options
+    });
+    const processInfo = {
+      id,
+      pid: proc.pid,
+      command,
+      args,
+      startTime: Date.now(),
+      process: proc
+    };
+    this.processes.set(id, processInfo);
+    proc.on("exit", (code, signal) => {
+      this.logger.info(`\u8FDB\u7A0B ${id} \u5DF2\u9000\u51FA (code: ${code}, signal: ${signal})`);
+      this.processes.delete(id);
+    });
+    proc.on("error", (err) => {
+      this.logger.error(`\u8FDB\u7A0B ${id} \u51FA\u9519: ${err.message}`);
+      this.processes.delete(id);
+    });
+    return processInfo;
+  }
+  /**
+   * 停止进程
+   * @param id - 进程ID
+   * @param signal - 信号（默认为 SIGTERM）
+   * @returns 是否成功停止
+   */
+  kill(id, signal = "SIGTERM") {
+    const processInfo = this.processes.get(id);
+    if (!processInfo) {
+      this.logger.warn(`\u8FDB\u7A0B ${id} \u4E0D\u5B58\u5728`);
+      return false;
+    }
+    this.logger.info(`\u505C\u6B62\u8FDB\u7A0B: ${id} (PID: ${processInfo.pid})`);
+    try {
+      const killed = processInfo.process.kill(signal);
+      if (killed) {
+        this.processes.delete(id);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      this.logger.error(`\u505C\u6B62\u8FDB\u7A0B ${id} \u5931\u8D25: ${error}`);
+      return false;
+    }
+  }
+  /**
+   * 检查进程是否存在
+   * @param id - 进程ID
+   * @returns 是否存在
+   */
+  has(id) {
+    return this.processes.has(id);
+  }
+  /**
+   * 检查进程是否在运行
+   * @param id - 进程 ID
+   * @returns 是否在运行
+   */
+  isRunning(id) {
+    const processInfo = this.processes.get(id);
+    if (!processInfo) return false;
+    try {
+      return process.kill(processInfo.pid, 0);
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * 停止所有进程
+   * @param signal - 信号（默认为 SIGTERM）
+   */
+  killAll(signal = "SIGTERM") {
+    if (this.processes.size === 0) {
+      return;
+    }
+    this.logger.info(`\u505C\u6B62\u6240\u6709\u8FDB\u7A0B (${this.processes.size} \u4E2A)`);
+    for (const [id, processInfo] of this.processes) {
+      try {
+        processInfo.process.kill(signal);
+        this.logger.info(`\u5DF2\u505C\u6B62\u8FDB\u7A0B: ${id}`);
+      } catch (error) {
+        this.logger.error(`\u505C\u6B62\u8FDB\u7A0B ${id} \u5931\u8D25: ${error}`);
+      }
+    }
+    this.processes.clear();
+  }
+};
+
+// services/git/service.ts
+var GitService = class {
+  constructor() {
+    this.gitManager = new GitManager(ROOT_DIR_PATH);
+  }
+  /**
+   * 推送到远程仓库
+   * @param options - 推送选项
+   */
+  async push(options = {}) {
+    const { message, branch, force = false } = options;
+    logger.info("Pushing to remote repository...");
+    if (message) {
+      await this.gitManager.pushWithCommit(message, { force });
+    } else {
+      await this.gitManager.push({ setUpstream: !!branch, force });
+    }
+    logger.info("Push completed successfully");
+  }
+  /**
+   * 从远程仓库拉取
+   * @param options - 拉取选项
+   */
+  async pull(options = {}) {
+    const { rebase = false } = options;
+    logger.info("Pulling from remote repository...");
+    await this.gitManager.pull({ rebase });
+    logger.info("Pull completed successfully");
+  }
+  /**
+   * 同步本地和远程仓库（先拉取后推送）
+   * @param commitMessage - 可选的提交信息
+   */
+  async sync(commitMessage) {
+    logger.info("Syncing with remote repository...");
+    await this.gitManager.sync({ commitMessage });
+    logger.info("Sync completed successfully");
+  }
+  /**
+   * 获取 Git 状态
+   * @returns Git 状态信息
+   */
+  async getStatus() {
+    return await this.gitManager.getStatus();
+  }
+  /**
+   * 检查是否有未提交的更改
+   * @returns 是否有未提交的更改
+   */
+  async hasChanges() {
+    const status = await this.getStatus();
+    return status.hasChanges;
+  }
+  /**
+   * 生成自动提交信息
+   * @returns 自动生成的提交信息
+   */
+  generateCommitMessage() {
+    const date = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    const time = (/* @__PURE__ */ new Date()).toTimeString().split(" ")[0];
+    return `\u{1F4DD} Update notes - ${date} ${time}`;
+  }
+  /**
+   * 快速提交并推送（使用自动生成的提交信息）
+   * @param options - 推送选项
+   */
+  async quickPush(options = {}) {
+    if (!options.skipCheck && !await this.hasChanges()) {
+      logger.info("No changes to commit");
+      return;
+    }
+    const message = this.generateCommitMessage();
+    await this.push({ message, force: options.force });
+  }
+};
+
+// services/sync-core/service.ts
+import { existsSync as existsSync7 } from "fs";
+import { join as join7, basename as basename2 } from "path";
+var SyncCoreService = class {
+  /**
+   * 同步单个仓库的 submodule 到最新版本
+   */
+  async syncSingleRepo(targetDir) {
+    const repoName = basename2(targetDir);
+    const submodulePath = join7(targetDir, ".vitepress", "tnotes");
+    try {
+      if (!existsSync7(join7(targetDir, ".gitmodules"))) {
+        return {
+          dir: targetDir,
+          repoName,
+          success: false,
+          updated: false,
+          error: "\u672A\u627E\u5230 .gitmodules\uFF0C\u8BE5\u4ED3\u5E93\u672A\u914D\u7F6E submodule"
+        };
+      }
+      if (!existsSync7(submodulePath)) {
+        await runCommand("git submodule update --init", targetDir);
+      }
+      const beforeHash = (await runCommand("git rev-parse HEAD", submodulePath)).trim();
+      const beforeTime = (await runCommand("git log -1 --format=%ci HEAD", submodulePath)).trim().replace(/ [+-]\d{4}$/, "");
+      await runCommand("git fetch origin", submodulePath);
+      await runCommand("git reset --hard origin/main", submodulePath);
+      const afterHash = (await runCommand("git rev-parse HEAD", submodulePath)).trim();
+      const afterTime = (await runCommand("git log -1 --format=%ci HEAD", submodulePath)).trim().replace(/ [+-]\d{4}$/, "");
+      const updated = beforeHash !== afterHash;
+      if (updated) {
+        await runCommand("git add .vitepress/tnotes", targetDir);
+        await runCommand('git commit -m "chore: update TNotes.core"', targetDir);
+      }
+      return {
+        dir: targetDir,
+        repoName,
+        success: true,
+        updated,
+        beforeHash: beforeHash.substring(0, 7),
+        beforeTime,
+        afterHash: afterHash.substring(0, 7),
+        afterTime
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return {
+        dir: targetDir,
+        repoName,
+        success: false,
+        updated: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * 同步所有兄弟仓库的 TNotes.core 到最新版本
+   */
+  async syncToAllRepos() {
+    try {
+      const targetDirs = getTargetDirs(TNOTES_BASE_DIR, "TNotes.", [
+        ROOT_DIR_PATH,
+        TNOTES_CORE_DIR,
+        EN_WORDS_DIR
+      ]);
+      if (targetDirs.length === 0) {
+        logger.warn("\u672A\u627E\u5230\u7B26\u5408\u6761\u4EF6\u7684\u76EE\u6807\u76EE\u5F55");
+        return;
+      }
+      logger.info(`\u6B63\u5728\u540C\u6B65 ${targetDirs.length} \u4E2A\u4ED3\u5E93\u7684 TNotes.core...`);
+      console.log();
+      const results = [];
+      for (let i = 0; i < targetDirs.length; i++) {
+        const dir = targetDirs[i];
+        const repoName = basename2(dir);
+        logger.info(`[${i + 1}/${targetDirs.length}] ${repoName}`);
+        const result = await this.syncSingleRepo(dir);
+        results.push(result);
+        if (result.success) {
+          if (result.updated) {
+            logger.success(
+              `  \u2713 \u5DF2\u66F4\u65B0 ${result.beforeHash}(${result.beforeTime}) \u2192 ${result.afterHash}(${result.afterTime})
+`
+            );
+          } else {
+            logger.info(
+              `  - \u5DF2\u662F\u6700\u65B0 ${result.afterHash}(${result.afterTime})
+`
+            );
+          }
+        } else {
+          logger.error(`  \u2717 \u5931\u8D25: ${result.error}
+`);
+        }
+      }
+      const successCount = results.filter((r) => r.success).length;
+      const updatedCount = results.filter((r) => r.updated).length;
+      const failCount = results.length - successCount;
+      console.log("\u2501".repeat(50));
+      if (failCount === 0) {
+        logger.success(
+          `\u2728 \u540C\u6B65\u5B8C\u6210: ${updatedCount} \u4E2A\u4ED3\u5E93\u5DF2\u66F4\u65B0, ${successCount - updatedCount} \u4E2A\u5DF2\u662F\u6700\u65B0 (\u5171 ${results.length} \u4E2A)`
+        );
+      } else {
+        logger.warn(
+          `\u26A0\uFE0F  \u540C\u6B65\u5B8C\u6210: ${successCount} \u6210\u529F (${updatedCount} \u66F4\u65B0), ${failCount} \u5931\u8D25 (\u5171 ${results.length} \u4E2A)`
+        );
+        console.log("\n\u5931\u8D25\u7684\u4ED3\u5E93:");
+        results.filter((r) => !r.success).forEach((r, index) => {
+          console.log(`  ${index + 1}. ${r.repoName}`);
+          console.log(`     \u9519\u8BEF: ${r.error}`);
+        });
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`TNotes.core \u540C\u6B65\u5931\u8D25: ${errorMessage}`);
+      throw error;
+    }
+  }
+};
+
+// services/timestamp/service.ts
+import {
+  existsSync as existsSync8,
+  readFileSync as readFileSync5,
+  writeFileSync as writeFileSync4,
+  readdirSync as readdirSync2,
+  statSync as statSync2
+} from "fs";
+import { join as join8 } from "path";
+import { execSync } from "child_process";
+var BIRTH_DATE = (/* @__PURE__ */ new Date("1999-06-29T00:00:00+08:00")).getTime();
+var TimestampService = class {
+  constructor() {
+    this.noteManager = NoteManager.getInstance();
+  }
+  /**
+   * 从 git 获取文件的创建时间和最后修改时间
+   * @param noteDirPath - 笔记目录路径
+   * @returns 时间戳对象，包含 created_at 和 updated_at
+   */
+  getGitTimestamps(noteDirPath) {
+    try {
+      const readmePath = join8(noteDirPath, "README.md");
+      const createdAtOutput = execSync(
+        `git log --diff-filter=A --follow --format=%ct -- "${readmePath}"`,
+        {
+          cwd: ROOT_DIR_PATH,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"]
+        }
+      ).split(/\r?\n/).filter(Boolean).pop();
+      const updatedAtOutput = execSync(
+        `git log -1 --format=%ct -- "${readmePath}"`,
+        {
+          cwd: ROOT_DIR_PATH,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"]
+        }
+      ).trim();
+      if (!createdAtOutput || !updatedAtOutput) {
+        return null;
+      }
+      return {
+        created_at: parseInt(createdAtOutput) * 1e3,
+        // 转换为毫秒
+        updated_at: parseInt(updatedAtOutput) * 1e3
+      };
+    } catch (error) {
+      logger.debug?.(`getGitTimestamps failed: ${noteDirPath}`, error);
+      return null;
+    }
+  }
+  /**
+   * 修复单个笔记的时间戳
+   * @param noteDir - 笔记目录名
+   * @param forceUpdate - 是否强制更新（忽略现有值）
+   * @returns 是否进行了修复
+   */
+  fixNoteTimestamps(noteDir, forceUpdate = false) {
+    const configPath = join8(NOTES_DIR_PATH, noteDir, ".tnotes.json");
+    if (!existsSync8(configPath)) {
+      return false;
+    }
+    try {
+      const configContent = readFileSync5(configPath, "utf-8");
+      const config = JSON.parse(configContent);
+      const noteDirPath = join8(NOTES_DIR_PATH, noteDir);
+      const timestamps = this.getGitTimestamps(noteDirPath);
+      if (!timestamps) {
+        return false;
+      }
+      let modified = false;
+      if (forceUpdate || !config.created_at || config.created_at !== timestamps.created_at) {
+        config.created_at = timestamps.created_at;
+        modified = true;
+      }
+      if (forceUpdate) {
+        if (config.updated_at !== timestamps.updated_at) {
+          config.updated_at = timestamps.updated_at;
+          modified = true;
+        }
+      } else {
+        if (!config.updated_at) {
+          config.updated_at = timestamps.updated_at;
+          modified = true;
+        } else if (timestamps.updated_at > config.updated_at) {
+          config.updated_at = timestamps.updated_at;
+          modified = true;
+        }
+      }
+      if (modified) {
+        this.noteManager.writeNoteConfig(configPath, config);
+        return true;
+      }
+      return false;
+    } catch (error) {
+      logger.error(`\u4FEE\u590D\u65F6\u95F4\u6233\u5931\u8D25: ${noteDir}`, error);
+      return false;
+    }
+  }
+  /**
+   * 修复根配置文件的时间戳
+   * @param forceUpdate - 是否强制更新
+   * @returns 是否进行了修复
+   */
+  fixRootConfigTimestamps(forceUpdate = false) {
+    try {
+      const configContent = readFileSync5(ROOT_CONFIG_PATH, "utf-8");
+      const config = JSON.parse(configContent);
+      const createdAtOutput = execSync("git log --reverse --format=%ct", {
+        cwd: ROOT_DIR_PATH,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+      const updatedAtOutput = execSync("git log -1 --format=%ct", {
+        cwd: ROOT_DIR_PATH,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+      if (!createdAtOutput || !updatedAtOutput) {
+        return false;
+      }
+      const firstTimestamp = createdAtOutput.split("\n")[0];
+      const createdAt = parseInt(firstTimestamp) * 1e3;
+      const updatedAt = parseInt(updatedAtOutput) * 1e3;
+      let modified = false;
+      if (forceUpdate || !config.root_item.created_at || config.root_item.created_at !== createdAt) {
+        config.root_item.created_at = createdAt;
+        modified = true;
+      }
+      if (forceUpdate || !config.root_item.updated_at || config.root_item.updated_at !== updatedAt) {
+        config.root_item.updated_at = updatedAt;
+        modified = true;
+      }
+      if (modified) {
+        const daysSinceBirth = Math.floor((updatedAt - BIRTH_DATE) / (1e3 * 60 * 60 * 24)) + 1;
+        config.root_item.days_since_birth = daysSinceBirth;
+        writeFileSync4(
+          ROOT_CONFIG_PATH,
+          JSON.stringify(config, null, 2) + "\n",
+          "utf-8"
+        );
+        return true;
+      }
+      return false;
+    } catch (error) {
+      logger.error("\u4FEE\u590D\u6839\u914D\u7F6E\u6587\u4EF6\u65F6\u95F4\u6233\u5931\u8D25", error);
+      return false;
+    }
+  }
+  /**
+   * 修复所有笔记的时间戳
+   * @param forceUpdate - 是否强制更新（忽略现有值，用于修复历史错误数据）
+   * @returns 修复统计信息
+   */
+  async fixAllTimestamps(forceUpdate = false) {
+    if (forceUpdate) {
+      logger.info("\u6B63\u5728\u5F3A\u5236\u4FEE\u590D\u7B14\u8BB0\u65F6\u95F4\u6233\uFF08\u4F7F\u7528 git \u771F\u5B9E\u65F6\u95F4\uFF09...");
+    } else {
+      logger.info("\u6B63\u5728\u4FEE\u590D\u7B14\u8BB0\u65F6\u95F4\u6233...");
+    }
+    const rootConfigFixed = this.fixRootConfigTimestamps(forceUpdate);
+    if (rootConfigFixed) {
+      logger.success("\u2705 \u6839\u914D\u7F6E\u6587\u4EF6\u65F6\u95F4\u6233\u5DF2\u4FEE\u590D");
+    }
+    if (!existsSync8(NOTES_DIR_PATH)) {
+      logger.error("notes \u76EE\u5F55\u4E0D\u5B58\u5728");
+      return { fixed: 0, skipped: 0, total: 0, rootConfigFixed };
+    }
+    const noteDirs = readdirSync2(NOTES_DIR_PATH).filter((name) => {
+      const fullPath = join8(NOTES_DIR_PATH, name);
+      return statSync2(fullPath).isDirectory() && /^\d{4}\./.test(name);
+    }).sort();
+    let fixedCount = 0;
+    let skippedCount = 0;
+    for (const noteDir of noteDirs) {
+      const fixed = this.fixNoteTimestamps(noteDir, forceUpdate);
+      if (fixed) {
+        fixedCount++;
+      } else {
+        skippedCount++;
+      }
+    }
+    if (fixedCount > 0) {
+      logger.success(`\u65F6\u95F4\u6233\u4FEE\u590D\u5B8C\u6210: ${fixedCount} \u4E2A\u7B14\u8BB0\u5DF2\u66F4\u65B0`);
+    } else {
+      logger.info("\u6240\u6709\u7B14\u8BB0\u65F6\u95F4\u6233\u5747\u5DF2\u6B63\u786E");
+    }
+    return {
+      fixed: fixedCount,
+      skipped: skippedCount,
+      total: noteDirs.length,
+      rootConfigFixed
+    };
+  }
+  /**
+   * 更新指定笔记的时间戳为当前时间
+   * @param noteDirNames - 笔记目录名数组
+   * @returns 更新的笔记数量
+   */
+  async updateNotesTimestamp(noteDirNames) {
+    if (noteDirNames.length === 0) {
+      return 0;
+    }
+    const now = Date.now();
+    let updatedCount = 0;
+    for (const noteDir of noteDirNames) {
+      const configPath = join8(NOTES_DIR_PATH, noteDir, ".tnotes.json");
+      if (!existsSync8(configPath)) {
+        continue;
+      }
+      try {
+        const configContent = readFileSync5(configPath, "utf-8");
+        const config = JSON.parse(configContent);
+        config.updated_at = now;
+        this.noteManager.writeNoteConfig(configPath, config);
+        updatedCount++;
+      } catch (error) {
+        logger.error(`\u66F4\u65B0\u65F6\u95F4\u6233\u5931\u8D25: ${noteDir}`, error);
+      }
+    }
+    return updatedCount;
+  }
+  /**
+   * 获取本次变更中包含 README.md 的笔记列表
+   * @param changedFiles - git status 返回的变更文件列表
+   * @returns 变更的笔记目录名数组
+   */
+  getChangedNotes(changedFiles) {
+    const changedNotes = /* @__PURE__ */ new Set();
+    for (let file of changedFiles) {
+      file = file.replace(/^"(.*)"$/, "$1").replace(/"$/, "");
+      const match = file.match(/^notes\/([^/]+)\/README\.md$/);
+      if (match) {
+        changedNotes.add(match[1]);
+      }
+    }
+    return Array.from(changedNotes);
+  }
+};
+
+// services/vitepress/service.ts
+import { spawn as spawn2 } from "child_process";
+var VitepressService = class _VitepressService {
+  static {
+    /** VitePress 开发服务器默认端口 */
+    this.DEFAULT_DEV_PORT = 5173;
+  }
+  static {
+    /** VitePress 预览服务器默认端口 */
+    this.DEFAULT_PREVIEW_PORT = 4173;
+  }
+  static {
+    /** 开发服务器进程 ID 后缀 */
+    this.PROCESS_ID_DEV_SUFFIX = "vitepress-dev";
+  }
+  static {
+    /** 预览服务器进程 ID 后缀 */
+    this.PROCESS_ID_PREVIEW_SUFFIX = "vitepress-preview";
+  }
+  static {
+    /** 服务启动超时时间（毫秒） */
+    this.SERVER_STARTUP_TIMEOUT = 6e4;
+  }
+  static {
+    /** 端口释放等待超时时间（毫秒） */
+    this.PORT_RELEASE_TIMEOUT = 3e3;
+  }
+  static {
+    /** 进程清理等待时间（毫秒） */
+    this.PROCESS_CLEANUP_DELAY = 3e3;
+  }
+  static {
+    /** 显示启动服务状态行间隔（毫秒） */
+    this.SERVER_STATUS_LINE_INTERVAL = 1e3;
+  }
+  static {
+    /** 默认包管理器 */
+    this.DEFAULT_PACKAGE_MANAGER = "pnpm";
+  }
+  constructor() {
+    this.processManager = new ProcessManager();
+    this.configManager = ConfigManager.getInstance();
+  }
+  /**
+   * 启动 VitePress 开发服务器
+   * @returns 启动结果（服务就绪后返回），失败时返回 undefined
+   */
+  async startServer() {
+    const port = this.configManager.get("port") || _VitepressService.DEFAULT_DEV_PORT;
+    const repoName = this.configManager.get("repoName");
+    const processId = `${repoName}-${_VitepressService.PROCESS_ID_DEV_SUFFIX}`;
+    if (this.processManager.has(processId) && this.processManager.isRunning(processId)) {
+      this.processManager.kill(processId);
+      await new Promise(
+        (resolve3) => setTimeout(resolve3, _VitepressService.PROCESS_CLEANUP_DELAY)
+      );
+    }
+    if (isPortInUse(port)) {
+      logger.warn(`\u7AEF\u53E3 ${port} \u88AB\u5360\u7528\uFF0C\u6B63\u5728\u6E05\u7406...`);
+      killPortProcess(port);
+      const available = await waitForPort(
+        port,
+        _VitepressService.PORT_RELEASE_TIMEOUT
+      );
+      if (available) {
+        logger.info(`\u7AEF\u53E3 ${port} \u5DF2\u91CA\u653E\uFF0C\u7EE7\u7EED\u542F\u52A8\u670D\u52A1`);
+      } else {
+        logger.warn(
+          `\u7AEF\u53E3 ${port} \u672A\u786E\u8BA4\u91CA\u653E\uFF0C\u4ECD\u5C06\u5C1D\u8BD5\u542F\u52A8\uFF1B\u5982\u542F\u52A8\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6E05\u7406\u8BE5\u7AEF\u53E3`
+        );
+      }
+    }
+    const pm = this.configManager.get("packageManager") || _VitepressService.DEFAULT_PACKAGE_MANAGER;
+    const args = ["vitepress", "dev", "--port", port.toString()];
+    const processInfo = this.processManager.spawn(processId, pm, args, {
+      cwd: ROOT_DIR_PATH,
+      stdio: ["inherit", "pipe", "pipe"]
+      // stdin 继承，stdout/stderr 管道捕获
+    });
+    const serverInfo = await this.waitForServerReady(processInfo.process);
+    if (!processInfo.pid) return void 0;
+    return {
+      pid: processInfo.pid,
+      version: serverInfo.version,
+      elapsed: serverInfo.elapsed
+    };
+  }
+  /**
+   * 等待服务就绪，显示启动状态
+   * @param childProcess - 子进程
+   */
+  waitForServerReady(childProcess) {
+    return new Promise((resolve3) => {
+      const startTime = Date.now();
+      let serverReady = false;
+      let version = "";
+      const statusTimer = setInterval(() => {
+        if (serverReady) {
+          clearInterval(statusTimer);
+          return;
+        }
+        const elapsed = Date.now() - startTime;
+        const seconds = (elapsed / 1e3).toFixed(0);
+        process.stderr.clearLine?.(0);
+        process.stderr.cursorTo?.(0);
+        process.stderr.write(`\u23F3 \u542F\u52A8\u4E2D: \u5DF2\u7528 ${seconds}s...`);
+      }, _VitepressService.SERVER_STATUS_LINE_INTERVAL);
+      const handleOutput = (data) => {
+        const text = data.toString();
+        const versionMatch = text.match(/vitepress v([\d.]+)/);
+        if (versionMatch) {
+          version = versionMatch[1];
+        }
+        if (!serverReady && (text.includes("Local:") || text.includes("http://localhost") || text.includes("\u279C") && text.includes("Local"))) {
+          serverReady = true;
+          clearInterval(statusTimer);
+          process.stderr.clearLine?.(0);
+          process.stderr.cursorTo?.(0);
+          const elapsed = Date.now() - startTime;
+          setTimeout(() => resolve3({ version, elapsed }), 200);
+          return;
+        }
+        if (!serverReady) {
+          if (text.includes("error") || text.includes("Error") || text.includes("Port") && text.includes("is in use")) {
+            process.stderr.clearLine?.(0);
+            process.stderr.cursorTo?.(0);
+            process.stdout.write(data);
+          }
+        }
+      };
+      if (childProcess.stdout) {
+        childProcess.stdout.setEncoding("utf8");
+        childProcess.stdout.on("data", handleOutput);
+      }
+      if (childProcess.stderr) {
+        childProcess.stderr.setEncoding("utf8");
+        childProcess.stderr.on("data", handleOutput);
+      }
+      setTimeout(() => {
+        if (!serverReady) {
+          serverReady = true;
+          clearInterval(statusTimer);
+          process.stderr.clearLine?.(0);
+          process.stderr.cursorTo?.(0);
+          logger.warn("\u542F\u52A8\u8D85\u65F6\uFF0C\u8BF7\u68C0\u67E5 VitePress \u8F93\u51FA");
+          resolve3({ version, elapsed: _VitepressService.SERVER_STARTUP_TIMEOUT });
+        }
+      }, _VitepressService.SERVER_STARTUP_TIMEOUT);
+    });
+  }
+  /**
+   * 构建生产版本
+   */
+  build() {
+    return new Promise((resolve3, reject) => {
+      const pm = this.configManager.get("packageManager") || _VitepressService.DEFAULT_PACKAGE_MANAGER;
+      const child = spawn2(pm, ["vitepress", "build"], {
+        cwd: ROOT_DIR_PATH,
+        shell: true,
+        stdio: ["inherit", "pipe", "pipe"]
+      });
+      const filterOutput = (data) => {
+        const str = data.toString();
+        if (str.includes("\u{1F528}") || str.includes("\u2705 \u6784\u5EFA\u6210\u529F") || str.includes("\u274C \u6784\u5EFA\u5931\u8D25") || str.includes("\u{1F4C1}") || str.includes("\u{1F4CA}") || str.includes("\u{1F4E6}") || str.includes("\u23F1\uFE0F") || str.includes("Building [") || str.includes("error") || str.includes("Error")) {
+          process.stdout.write(data);
+          return;
+        }
+        if (/^[\s⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏✓\r\n]*$/.test(str) || str.includes("building client + server") || str.includes("rendering pages") || str.includes("generating sitemap") || str.includes("build complete in") || str.includes("vitepress v")) {
+          return;
+        }
+      };
+      child.stdout?.on("data", filterOutput);
+      child.stderr?.on("data", filterOutput);
+      child.on("error", (err) => {
+        reject(err);
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve3();
+        } else {
+          reject(new Error(`Command failed with code ${code}`));
+        }
+      });
+    });
+  }
+  /**
+   * 预览构建后的站点
+   */
+  async preview() {
+    const repoName = this.configManager.get("repoName");
+    const processId = `${repoName}-${_VitepressService.PROCESS_ID_PREVIEW_SUFFIX}`;
+    const pm = this.configManager.get("packageManager") || _VitepressService.DEFAULT_PACKAGE_MANAGER;
+    const args = ["vitepress", "preview"];
+    const previewPort = _VitepressService.DEFAULT_PREVIEW_PORT;
+    if (isPortInUse(previewPort)) {
+      logger.warn(`\u7AEF\u53E3 ${previewPort} \u5DF2\u88AB\u5360\u7528\uFF0C\u6B63\u5728\u5C1D\u8BD5\u6E05\u7406...`);
+      const killed = killPortProcess(previewPort);
+      if (killed) {
+        const available = await waitForPort(
+          previewPort,
+          _VitepressService.PORT_RELEASE_TIMEOUT
+        );
+        if (!available) {
+          logger.error(`\u7AEF\u53E3 ${previewPort} \u91CA\u653E\u8D85\u65F6\uFF0C\u8BF7\u624B\u52A8\u6E05\u7406`);
+          return void 0;
+        }
+        logger.info(`\u7AEF\u53E3 ${previewPort} \u5DF2\u91CA\u653E`);
+      } else {
+        logger.error(
+          `\u65E0\u6CD5\u6E05\u7406\u7AEF\u53E3 ${previewPort}\uFF0C\u8BF7\u624B\u52A8\u6267\u884C: taskkill /F /PID <PID>`
+        );
+        return void 0;
+      }
+    }
+    const processInfo = this.processManager.spawn(processId, pm, args, {
+      cwd: ROOT_DIR_PATH,
+      stdio: "inherit"
+    });
+    return processInfo.pid;
+  }
+};
+
+// commands/update/UpdateCommand.ts
+import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve2 } from "path";
+var UpdateCommand = class extends BaseCommand {
+  constructor() {
+    super("update");
+    this.quiet = false;
+    this.updateAll = false;
+    this.readmeService = ReadmeService.getInstance();
+    this.noteService = NoteService.getInstance();
+  }
+  /**
+   * 设置 quiet 模式
+   *
+   * 在 quiet 模式下，只显示 WARN 级别以上的日志
+   */
+  setQuiet(quiet) {
+    this.quiet = quiet;
+    if (quiet) {
+      logger.setLevel(2 /* WARN */);
+    } else {
+      logger.setLevel(1 /* INFO */);
+    }
+  }
+  /**
+   * 设置是否更新所有知识库
+   */
+  setUpdateAll(updateAll) {
+    this.updateAll = updateAll;
+  }
+  async run() {
+    if (this.updateAll) {
+      await this.updateAllRepos();
+    } else {
+      await this.updateCurrentRepo();
+    }
+  }
+  /**
+   * 更新当前知识库
+   */
+  async updateCurrentRepo() {
+    const startTime = Date.now();
+    const notes = this.noteService.getAllNotes();
+    if (!this.quiet) {
+      this.logger.info("\u6B63\u5728\u4FEE\u6B63\u7B14\u8BB0\u6807\u9898...");
+    }
+    const fixedCount = await this.noteService.fixAllNoteTitles(notes);
+    if (!this.quiet && fixedCount > 0) {
+      this.logger.success(`\u4FEE\u6B63\u4E86 ${fixedCount} \u4E2A\u7B14\u8BB0\u6807\u9898`);
+    }
+    await this.readmeService.updateAllReadmes({ notes });
+    await this.updateRootItem();
+    const duration = Date.now() - startTime;
+    if (this.quiet) {
+      this.logger.success(`\u77E5\u8BC6\u5E93\u66F4\u65B0\u5B8C\u6210 (${duration}ms)`);
+    } else {
+      this.logger.success("\u77E5\u8BC6\u5E93\u66F4\u65B0\u5B8C\u6210");
+    }
+  }
+  /**
+   * 更新所有知识库
+   */
+  async updateAllRepos() {
+    try {
+      const targetDirs = getTargetDirs(TNOTES_BASE_DIR, "TNotes.", [
+        ROOT_DIR_PATH,
+        EN_WORDS_DIR
+      ]);
+      if (targetDirs.length === 0) {
+        this.logger.warn("\u672A\u627E\u5230\u7B26\u5408\u6761\u4EF6\u7684\u77E5\u8BC6\u5E93");
+        return;
+      }
+      this.logger.info(`\u6B63\u5728\u66F4\u65B0 ${targetDirs.length} \u4E2A\u77E5\u8BC6\u5E93...`);
+      let successCount = 0;
+      let failCount = 0;
+      for (let i = 0; i < targetDirs.length; i++) {
+        const dir = targetDirs[i];
+        const repoName = dir.split("/").pop() || dir;
+        try {
+          process.stdout.write(
+            `\r  [${i + 1}/${targetDirs.length}] \u6B63\u5728\u66F4\u65B0: ${repoName}...`
+          );
+          await runCommand("pnpm tn:update --quiet", dir);
+          successCount++;
+        } catch (error) {
+          failCount++;
+          console.log();
+          this.logger.error(
+            `\u66F4\u65B0\u5931\u8D25: ${repoName} - ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      console.log();
+      if (failCount === 0) {
+        this.logger.success(
+          `\u2705 \u6240\u6709\u77E5\u8BC6\u5E93\u66F4\u65B0\u5B8C\u6210: ${successCount}/${targetDirs.length}`
+        );
+      } else {
+        this.logger.warn(
+          `\u26A0\uFE0F  \u66F4\u65B0\u5B8C\u6210: ${successCount} \u6210\u529F, ${failCount} \u5931\u8D25 (\u5171 ${targetDirs.length} \u4E2A)`
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `\u6279\u91CF\u66F4\u65B0\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * 更新 root_item 配置
+   * 只更新当前月份的完成笔记数量
+   */
+  async updateRootItem() {
+    try {
+      const configContent = readFileSync6(ROOT_CONFIG_PATH, "utf-8");
+      const config = JSON.parse(configContent);
+      const readmePath = resolve2(ROOT_DIR_PATH, "README.md");
+      if (!existsSync9(readmePath)) {
+        throw new Error("\u6839\u76EE\u5F55 README.md \u4E0D\u5B58\u5728");
+      }
+      const readmeContent = readFileSync6(readmePath, "utf-8");
+      const { completedCount } = parseReadmeCompletedNotes(readmeContent);
+      const now = /* @__PURE__ */ new Date();
+      const yearShort = String(now.getFullYear()).slice(-2);
+      const monthStr = String(now.getMonth() + 1).padStart(2, "0");
+      const currentKey = `${yearShort}.${monthStr}`;
+      const completedNotesCount = {
+        ...config.root_item.completed_notes_count || {},
+        [currentKey]: completedCount
+      };
+      const updatedAt = Date.now();
+      config.root_item = {
+        ...config.root_item,
+        completed_notes_count: completedNotesCount,
+        updated_at: updatedAt
+      };
+      delete config.root_item.completed_notes_count_last_month;
+      writeFileSync5(ROOT_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+      if (!this.quiet) {
+        this.logger.success(
+          `root_item \u914D\u7F6E\u5DF2\u66F4\u65B0: ${currentKey} \u6708\u5B8C\u6210 ${completedCount} \u7BC7\u7B14\u8BB0`
+        );
+      }
+    } catch (error) {
+      if (!this.quiet) {
+        this.logger.error(
+          `\u66F4\u65B0 root_item \u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      throw error;
+    }
+  }
+};
+
+// commands/update-completed-count/UpdateCompletedCountCommand.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { execSync as execSync2 } from "child_process";
+var UpdateCompletedCountCommand = class extends BaseCommand {
+  constructor() {
+    super("update-completed-count");
+    this.updateAll = false;
+  }
+  /**
+   * 设置是否更新所有知识库
+   */
+  setUpdateAll(updateAll) {
+    this.updateAll = updateAll;
+  }
+  async run() {
+    if (this.updateAll) {
+      await this.updateAllRepos();
+    } else {
+      await this.updateCurrentRepo();
+    }
+  }
+  /**
+   * 更新当前知识库
+   */
+  async updateCurrentRepo() {
+    const startTime = Date.now();
+    try {
+      const configContent = readFileSync7(ROOT_CONFIG_PATH, "utf-8");
+      const config = JSON.parse(configContent);
+      this.logger.info("\u5F00\u59CB\u66F4\u65B0\u5B8C\u6210\u7B14\u8BB0\u6570\u91CF\u5386\u53F2\u8BB0\u5F55...");
+      const completedNotesCountHistory = await this.getCompletedNotesCountHistory(config.root_item.created_at);
+      config.root_item = {
+        ...config.root_item,
+        completed_notes_count: completedNotesCountHistory,
+        updated_at: Date.now()
+      };
+      writeFileSync6(ROOT_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+      const duration = Date.now() - startTime;
+      const monthKeys = Object.keys(completedNotesCountHistory);
+      const currentKey = monthKeys[monthKeys.length - 1];
+      const currentCount = completedNotesCountHistory[currentKey] || 0;
+      this.logger.success(
+        `\u5386\u53F2\u6570\u636E\u66F4\u65B0\u5B8C\u6210: \u5171 ${monthKeys.length} \u4E2A\u6708, \u5F53\u524D ${currentKey} \u6708\u5B8C\u6210 ${currentCount} \u7BC7\u7B14\u8BB0 (${duration}ms)`
+      );
+    } catch (error) {
+      this.logger.error(
+        `\u66F4\u65B0\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * 更新所有知识库
+   */
+  async updateAllRepos() {
+    try {
+      const targetDirs = getTargetDirs(TNOTES_BASE_DIR, "TNotes.", [
+        ROOT_DIR_PATH,
+        EN_WORDS_DIR
+      ]);
+      if (targetDirs.length === 0) {
+        this.logger.warn("\u672A\u627E\u5230\u7B26\u5408\u6761\u4EF6\u7684\u77E5\u8BC6\u5E93");
+        return;
+      }
+      this.logger.info(
+        `\u6B63\u5728\u66F4\u65B0 ${targetDirs.length} \u4E2A\u77E5\u8BC6\u5E93\u7684\u5B8C\u6210\u6570\u91CF\u5386\u53F2\u8BB0\u5F55...`
+      );
+      let successCount = 0;
+      let failCount = 0;
+      for (let i = 0; i < targetDirs.length; i++) {
+        const dir = targetDirs[i];
+        const repoName = dir.split("/").pop() || dir;
+        try {
+          process.stdout.write(
+            `\r  [${i + 1}/${targetDirs.length}] \u6B63\u5728\u66F4\u65B0: ${repoName}...`
+          );
+          await runCommand("pnpm tn:update-completed-count", dir);
+          successCount++;
+        } catch (error) {
+          failCount++;
+          console.log();
+          this.logger.error(
+            `\u66F4\u65B0\u5931\u8D25: ${repoName} - ${error instanceof Error ? error.message : String(error)}`
+          );
+        }
+      }
+      console.log();
+      if (failCount === 0) {
+        this.logger.success(
+          `\u2705 \u6240\u6709\u77E5\u8BC6\u5E93\u5386\u53F2\u6570\u636E\u66F4\u65B0\u5B8C\u6210: ${successCount}/${targetDirs.length}`
+        );
+      } else {
+        this.logger.warn(
+          `\u26A0\uFE0F  \u66F4\u65B0\u5B8C\u6210: ${successCount} \u6210\u529F, ${failCount} \u5931\u8D25 (\u5171 ${targetDirs.length} \u4E2A)`
+        );
+      }
+    } catch (error) {
+      this.logger.error(
+        `\u6279\u91CF\u66F4\u65B0\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * 获取历史每个月的 completed_notes_count（最近12个月）
+   *
+   * 逻辑:
+   * 1. 计算最近12个月的范围（当前月份往前推11个月）
+   * 2. 遍历这12个月，从 Git 历史中读取 README.md
+   * 3. 解析 README.md 获取完成笔记数量
+   * 4. 如果知识库创建时间在这12个月内，之前的月份补0
+   * 5. 返回对象 { '25.01': 0, '25.02': 1, ..., '25.12': 15 }
+   */
+  async getCompletedNotesCountHistory(createdAt) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const currentYear = now.getFullYear();
+      const currentMonth = now.getMonth();
+      let firstYear = currentYear;
+      let firstMonth = currentMonth - 11;
+      if (firstMonth < 0) {
+        firstYear = currentYear - 1;
+        firstMonth = 12 + firstMonth;
+      }
+      const createdDate = new Date(createdAt);
+      const createdYear = createdDate.getFullYear();
+      const createdMonth = createdDate.getMonth();
+      const result = {};
+      let prevCount = 0;
+      for (let i = 0; i < 12; i++) {
+        const targetYear = firstYear + Math.floor((firstMonth + i) / 12);
+        const targetMonth = (firstMonth + i) % 12;
+        const yearShort = String(targetYear).slice(-2);
+        const monthStr = String(targetMonth + 1).padStart(2, "0");
+        const key = `${yearShort}.${monthStr}`;
+        const isBeforeCreation = targetYear < createdYear || targetYear === createdYear && targetMonth < createdMonth;
+        if (isBeforeCreation) {
+          result[key] = 0;
+          prevCount = 0;
+          this.logger.info(`\u2713 ${key}: 0 \u7BC7\uFF08\u65E9\u4E8E\u521B\u5EFA\u65F6\u95F4\uFF09`);
+        } else {
+          try {
+            const count = await this.getMonthCompletedCount(
+              targetYear,
+              targetMonth,
+              prevCount
+            );
+            result[key] = count;
+            prevCount = count;
+            this.logger.info(`\u2713 ${key}: ${count} \u7BC7`);
+          } catch (error) {
+            result[key] = prevCount;
+            this.logger.warn(`${key}: \u65E0\u6570\u636E\uFF0C\u4F7F\u7528 ${prevCount}\uFF08\u4E0A\u6708\u503C\uFF09`);
+          }
+        }
+      }
+      return result;
+    } catch (error) {
+      this.logger.error(
+        `\u83B7\u53D6\u5386\u53F2\u6570\u636E\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {};
+    }
+  }
+  /**
+   * 获取指定月份的完成笔记数量
+   * @param year - 年份
+   * @param month - 月份 (0-11)
+   * @param fallbackCount - 回退值（如果该月没有数据）
+   * @returns 完成笔记数量
+   */
+  async getMonthCompletedCount(year, month, fallbackCount = 0) {
+    const lastDayOfMonth = new Date(year, month + 1, 0, 23, 59, 59);
+    const yearStr = lastDayOfMonth.getFullYear();
+    const monthStr = String(lastDayOfMonth.getMonth() + 1).padStart(2, "0");
+    const dayStr = String(lastDayOfMonth.getDate()).padStart(2, "0");
+    const untilDate = `${yearStr}-${monthStr}-${dayStr} 23:59:59 +0800`;
+    const commitHash = execSync2(
+      `git log --until="${untilDate}" --format=%H -1 -- README.md`,
+      {
+        cwd: ROOT_DIR_PATH,
+        encoding: "utf-8"
+      }
+    ).trim();
+    if (!commitHash) {
+      return fallbackCount;
+    }
+    let readmeContent;
+    try {
+      readmeContent = execSync2(`git show ${commitHash}:README.md`, {
+        cwd: ROOT_DIR_PATH,
+        encoding: "utf-8"
+      });
+    } catch (error) {
+      return fallbackCount;
+    }
+    const { completedCount } = parseReadmeCompletedNotes(readmeContent);
+    return completedCount;
+  }
+};
+
+// commands/git/PushCommand.ts
+var PushCommand = class extends BaseCommand {
+  constructor() {
+    super("push");
+    this.pushAll = false;
+    this.gitService = new GitService();
+    this.timestampService = new TimestampService();
+  }
+  /**
+   * 设置是否推送所有仓库
+   */
+  setPushAll(value) {
+    this.pushAll = value;
+  }
+  async run() {
+    if (this.pushAll) {
+      const parallel = process.env.PARALLEL_PUSH === "true";
+      const force = this.options.force === true;
+      if (parallel) {
+        this.logger.info("Parallel push mode enabled");
+      }
+      if (force) {
+        this.logger.warn("\u4F7F\u7528\u5F3A\u5236\u63A8\u9001\u6A21\u5F0F (--force)");
+      }
+      await pushAllRepos({ parallel, force });
+      return;
+    }
+    try {
+      this.logger.info("\u68C0\u67E5\u662F\u5426\u6709\u66F4\u6539...");
+      const status = await this.gitService.getStatus();
+      const hasPendingCommits = (status.ahead ?? 0) > 0;
+      if (!status.hasChanges && !hasPendingCommits) {
+        this.logger.info("\u6CA1\u6709\u66F4\u6539\u9700\u8981\u63A8\u9001");
+        return;
+      }
+      if (hasPendingCommits && !status.hasChanges) {
+        this.logger.info(`\u68C0\u6D4B\u5230 ${status.ahead} \u4E2A\u672A\u63A8\u9001\u7684\u63D0\u4EA4\uFF0C\u76F4\u63A5\u63A8\u9001...`);
+      }
+      if (status.hasChanges) {
+        const changedFiles = status.files.map((f) => f.path);
+        this.logger.info(`\u5171\u8BA1\u68C0\u6D4B\u5230 ${changedFiles.length} \u4E2A\u53D8\u66F4\u6587\u4EF6`);
+        const changedNotes = this.timestampService.getChangedNotes(changedFiles);
+        this.logger.info(
+          `\u5DE5\u5177\u68C0\u6D4B\u5230 ${changedNotes.length} \u4E2A\u53D8\u66F4\u7B14\u8BB0\uFF08README.md\uFF09`
+        );
+        if (changedNotes.length > 0) {
+          this.logger.info(
+            `\u68C0\u6D4B\u5230 ${changedNotes.length} \u7BC7\u7B14\u8BB0\u7684 README.md \u6709\u53D8\u66F4\uFF0C\u66F4\u65B0\u65F6\u95F4\u6233...`
+          );
+          await this.timestampService.updateNotesTimestamp(changedNotes);
+        }
+      }
+      const force = this.options.force === true;
+      if (force) {
+        this.logger.warn("\u4F7F\u7528\u5F3A\u5236\u63A8\u9001\u6A21\u5F0F (--force)");
+      }
+      this.logger.info("\u6B63\u5728\u63A8\u9001\u5230\u8FDC\u7A0B\u4ED3\u5E93...");
+      await this.gitService.quickPush({ force, skipCheck: true });
+      this.logger.success("\u63A8\u9001\u5B8C\u6210");
+    } catch (error) {
+      this.logger.error("\u63A8\u9001\u5931\u8D25:", error);
+      throw error;
+    }
+  }
+};
+
+// commands/git/PullCommand.ts
+var PullCommand = class extends BaseCommand {
+  constructor() {
+    super("pull");
+    this.pullAll = false;
+    this.gitService = new GitService();
+  }
+  /**
+   * 设置是否拉取所有仓库
+   */
+  setPullAll(value) {
+    this.pullAll = value;
+  }
+  async run() {
+    if (this.pullAll) {
+      const parallel = process.env.PARALLEL_PULL === "true";
+      if (parallel) {
+        this.logger.info("Parallel pull mode enabled");
+      }
+      await pullAllRepos({ parallel });
+      return;
+    }
+    this.logger.info("\u6B63\u5728\u4ECE\u8FDC\u7A0B\u4ED3\u5E93\u62C9\u53D6...");
+    await this.gitService.pull();
+    this.logger.success("\u62C9\u53D6\u5B8C\u6210");
+  }
+};
+
+// commands/git/SyncCommand.ts
+var SyncCommand = class extends BaseCommand {
+  constructor() {
+    super("sync");
+    this.syncAll = false;
+    this.gitService = new GitService();
+  }
+  /**
+   * 设置是否同步所有仓库
+   */
+  setSyncAll(value) {
+    this.syncAll = value;
+  }
+  async run() {
+    if (this.syncAll) {
+      await syncAllRepos({ parallel: false });
+      return;
+    }
+    this.logger.info("\u6B63\u5728\u540C\u6B65\u4ED3\u5E93...");
+    const hasChanges = await this.gitService.hasChanges();
+    if (hasChanges) {
+      const message = this.gitService.generateCommitMessage();
+      await this.gitService.sync(message);
+    } else {
+      await this.gitService.sync();
+    }
+    this.logger.success("\u540C\u6B65\u5B8C\u6210");
+  }
+};
+
+// commands/dev/DevCommand.ts
+var DevCommand = class extends BaseCommand {
+  constructor() {
+    super("dev");
+    this.fileWatcherService = new FileWatcherService();
+    this.vitepressService = new VitepressService();
+    this.noteManager = NoteManager.getInstance();
+    this.noteIndexCache = NoteIndexCache.getInstance();
+    this.configManager = ConfigManager.getInstance();
+  }
+  async run() {
+    const notes = this.noteManager.scanNotes();
+    this.logger.info(`\u626B\u63CF\u5230 ${notes.length} \u7BC7\u7B14\u8BB0`);
+    this.noteIndexCache.initialize(notes);
+    const result = await this.vitepressService.startServer();
+    if (result) {
+      const versionInfo = result.version ? `\uFF08v${result.version}\uFF09` : "";
+      this.logger.success(
+        `VitePress \u670D\u52A1${versionInfo}\u5DF2\u5C31\u7EEA\uFF0C\u8017\u65F6\uFF1A${result.elapsed} ms`
+      );
+      const watcherStart = Date.now();
+      this.fileWatcherService.start();
+      const watcherElapsed = Date.now() - watcherStart;
+      this.logger.success(`\u6587\u4EF6\u76D1\u542C\u670D\u52A1\u5DF2\u5C31\u7EEA\uFF0C\u8017\u65F6\uFF1A${watcherElapsed} ms`);
+      const port = this.configManager.get("port") || VitepressService.DEFAULT_DEV_PORT;
+      const repoName = this.configManager.get("repoName");
+      this.logger.info(
+        `\u672C\u5730\u5F00\u53D1\u670D\u52A1\u5730\u5740\uFF1Ahttp://localhost:${port}/${repoName}/`
+      );
+    } else {
+      this.logger.error("\u542F\u52A8\u670D\u52A1\u5668\u5931\u8D25");
+    }
+  }
+};
+
+// commands/build/BuildCommand.ts
+var BuildCommand = class extends BaseCommand {
+  constructor() {
+    super("build");
+    this.vitepressService = new VitepressService();
+  }
+  async run() {
+    this.logger.info("\u5F00\u59CB\u6784\u5EFA\u77E5\u8BC6\u5E93...");
+    await this.vitepressService.build();
+    this.logger.success("\u77E5\u8BC6\u5E93\u6784\u5EFA\u5B8C\u6210");
+  }
+};
+
+// commands/build/PreviewCommand.ts
+var PreviewCommand = class extends BaseCommand {
+  constructor() {
+    super("preview");
+    this.vitepressService = new VitepressService();
+  }
+  async run() {
+    this.logger.info("\u542F\u52A8\u9884\u89C8\u670D\u52A1\u5668...");
+    const pid = await this.vitepressService.preview();
+    if (pid) {
+      this.logger.success(`\u9884\u89C8\u670D\u52A1\u5668\u5DF2\u542F\u52A8 (PID: ${pid})`);
+    } else {
+      this.logger.error("\u542F\u52A8\u9884\u89C8\u670D\u52A1\u5668\u5931\u8D25");
+    }
+  }
+};
+
+// commands/note/CreateNoteCommand.ts
+import { createInterface } from "readline";
+import { v4 as uuidv42 } from "uuid";
+var CreateNoteCommand = class extends BaseCommand {
+  constructor() {
+    super("create-notes");
+    this.noteService = NoteService.getInstance();
+    this.readmeService = ReadmeService.getInstance();
+  }
+  async run() {
+    this.logger.info("\u521B\u5EFA\u65B0\u7B14\u8BB0...");
+    const count = await this.promptForCount();
+    let successCount = 0;
+    let failCount = 0;
+    const createdNotes = [];
+    const existingNotes = this.noteService.getAllNotes();
+    const usedIndexes = /* @__PURE__ */ new Set();
+    for (const note of existingNotes) {
+      const index = parseInt(note.index, 10);
+      if (!isNaN(index) && index >= 1 && index <= 9999) {
+        usedIndexes.add(index);
+      }
+    }
+    for (let i = 1; i <= count; i++) {
+      try {
+        let title;
+        if (count === 1) {
+          title = await this.promptForTitle();
+        } else {
+          title = `new`;
+          this.logger.info(`[${i}/${count}] \u521B\u5EFA\u7B14\u8BB0: ${title}`);
+        }
+        const configId = uuidv42();
+        const note = await this.noteService.createNote({
+          title: title || `new`,
+          enableDiscussions: false,
+          configId,
+          // 传递 UUID 作为配置 ID（跨知识库唯一）
+          usedIndexes
+          // 传入已使用编号集合，避免重复扫描
+        });
+        const newIndex = parseInt(note.index, 10);
+        if (!isNaN(newIndex)) {
+          usedIndexes.add(newIndex);
+        }
+        createdNotes.push(note.dirName);
+        successCount++;
+        if (count === 1) {
+          this.logger.success(`\u7B14\u8BB0\u521B\u5EFA\u6210\u529F: ${note.dirName}`);
+          this.logger.info(`\u7B14\u8BB0\u8DEF\u5F84: ${note.path}`);
+          this.logger.info(`\u7B14\u8BB0\u7F16\u53F7: ${note.index}`);
+          this.logger.info(`\u914D\u7F6EID: ${configId}`);
+        } else {
+          this.logger.success(`[${i}/${count}] \u521B\u5EFA\u6210\u529F: ${note.dirName}`);
+        }
+      } catch (error) {
+        failCount++;
+        this.logger.error(`[${i}/${count}] \u521B\u5EFA\u5931\u8D25`, error);
+      }
+    }
+    if (count > 1) {
+      console.log("");
+      this.logger.info(
+        `\u{1F4CA} \u521B\u5EFA\u5B8C\u6210: \u6210\u529F ${successCount} \u7BC7, \u5931\u8D25 ${failCount} \u7BC7`
+      );
+    }
+    if (successCount > 0) {
+      this.logger.info("\u6B63\u5728\u66F4\u65B0\u77E5\u8BC6\u5E93\u7D22\u5F15...");
+      await this.readmeService.updateAllReadmes();
+      this.logger.success("\u77E5\u8BC6\u5E93\u7D22\u5F15\u66F4\u65B0\u5B8C\u6210");
+    }
+  }
+  /**
+   * 提示用户输入要创建的笔记数量
+   */
+  async promptForCount() {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve3) => {
+      rl.question("\n\u{1F4DD} \u8BF7\u8F93\u5165\u8981\u521B\u5EFA\u7684\u7B14\u8BB0\u6570\u91CF\uFF08\u9ED8\u8BA4\u4E3A 1\uFF09: ", (answer) => {
+        rl.close();
+        const trimmed = answer.trim();
+        if (!trimmed) {
+          this.logger.info("\u4F7F\u7528\u9ED8\u8BA4\u6570\u91CF: 1");
+          resolve3(1);
+          return;
+        }
+        const num = parseInt(trimmed, 10);
+        if (isNaN(num) || num < 1 || !Number.isInteger(num)) {
+          this.logger.warn(`\u8F93\u5165 "${trimmed}" \u4E0D\u662F\u6709\u6548\u7684\u6B63\u6574\u6570\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u503C: 1`);
+          resolve3(1);
+          return;
+        }
+        this.logger.info(`\u5C06\u521B\u5EFA ${num} \u7BC7\u7B14\u8BB0`);
+        resolve3(num);
+      });
+    });
+  }
+  /**
+   * 提示用户输入笔记标题
+   */
+  async promptForTitle() {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve3) => {
+      rl.question("\u8BF7\u8F93\u5165\u7B14\u8BB0\u6807\u9898: ", (answer) => {
+        rl.close();
+        resolve3(answer.trim());
+      });
+    });
+  }
+};
+
+// commands/note/UpdateNoteConfigCommand.ts
+var UpdateNoteConfigCommand = class extends BaseCommand {
+  constructor() {
+    super("update-note-config");
+    this.noteService = NoteService.getInstance();
+  }
+  async run() {
+    const noteIndex = process.env.NOTE_ID;
+    const done = process.env.NOTE_DONE === "true";
+    const enableDiscussions = process.env.NOTE_DISCUSSIONS === "true";
+    const description = process.env.NOTE_DESCRIPTION || "";
+    if (!noteIndex) {
+      throw new Error("\u7F3A\u5C11 NOTE_ID \u53C2\u6570");
+    }
+    try {
+      await this.updateConfig({
+        noteIndex,
+        config: {
+          done,
+          enableDiscussions,
+          description
+        }
+      });
+      this.logger.success(`\u7B14\u8BB0 ${noteIndex} \u914D\u7F6E\u5DF2\u66F4\u65B0`);
+    } catch (error) {
+      this.logger.error("\u66F4\u65B0\u914D\u7F6E\u5931\u8D25", error);
+      throw error;
+    }
+  }
+  /**
+   * 更新笔记配置（可被外部调用）
+   */
+  async updateConfig(params) {
+    const { noteIndex, config } = params;
+    const note = this.noteService.getNoteByIndex(noteIndex);
+    if (!note) {
+      throw new Error(`\u7B14\u8BB0\u672A\u627E\u5230: ${noteIndex}`);
+    }
+    await this.noteService.updateNoteConfig(noteIndex, config);
+    this.logger.info(`\u2705 \u7B14\u8BB0 ${noteIndex} \u914D\u7F6E\u5DF2\u66F4\u65B0:`);
+    if (config.done !== void 0)
+      this.logger.info(`  - \u5B8C\u6210\u72B6\u6001: ${config.done}`);
+    if (config.enableDiscussions !== void 0)
+      this.logger.info(`  - \u8BC4\u8BBA\u72B6\u6001: ${config.enableDiscussions}`);
+    if (config.description !== void 0)
+      this.logger.info(`  - \u7B14\u8BB0\u7B80\u4ECB: ${config.description || "(\u7A7A)"}`);
+  }
+};
+
+// commands/note/RenameNoteCommand.ts
+import { existsSync as existsSync10, renameSync, readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { join as join9 } from "path";
+var RenameNoteCommand = class extends BaseCommand {
+  constructor() {
+    super("rename-note");
+    this.noteService = NoteService.getInstance();
+    this.readmeService = ReadmeService.getInstance();
+  }
+  async run() {
+    const noteIndex = process.env.NOTE_ID;
+    const newTitle = process.env.NOTE_TITLE;
+    if (!noteIndex || !newTitle) {
+      throw new Error("\u7F3A\u5C11 NOTE_ID \u6216 NOTE_TITLE \u53C2\u6570");
+    }
+    try {
+      await this.renameNote({ noteIndex, newTitle });
+      this.logger.success(`\u7B14\u8BB0 ${noteIndex} \u5DF2\u91CD\u547D\u540D\u4E3A: ${newTitle}`);
+    } catch (error) {
+      this.logger.error("\u91CD\u547D\u540D\u5931\u8D25", error);
+      throw error;
+    }
+  }
+  /**
+   * 重命名笔记（可被外部调用）
+   */
+  async renameNote(params) {
+    const { noteIndex, newTitle } = params;
+    const note = this.noteService.getNoteByIndex(noteIndex);
+    if (!note) {
+      throw new Error(`\u7B14\u8BB0\u672A\u627E\u5230: ${noteIndex}`);
+    }
+    const validation = validateNoteTitle(newTitle);
+    if (!validation.valid) {
+      throw new Error(validation.error || "\u6807\u9898\u683C\u5F0F\u65E0\u6548");
+    }
+    const newDirName = `${noteIndex}. ${newTitle.trim()}`;
+    const newPath = join9(NOTES_PATH, newDirName);
+    if (existsSync10(newPath)) {
+      throw new Error(`\u76EE\u6807\u6587\u4EF6\u5939\u5DF2\u5B58\u5728: ${newDirName}`);
+    }
+    try {
+      renameSync(note.path, newPath);
+      this.logger.info(`\u2705 \u6587\u4EF6\u5939\u5DF2\u91CD\u547D\u540D:`);
+      this.logger.info(`  \u539F\u540D\u79F0: ${note.dirName}`);
+      this.logger.info(`  \u65B0\u540D\u79F0: ${newDirName}`);
+    } catch (error) {
+      throw new Error(
+        `\u91CD\u547D\u540D\u6587\u4EF6\u5939\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    try {
+      this.logger.info("\u6B63\u5728\u66F4\u65B0\u7B14\u8BB0\u5185\u90E8\u6807\u9898...");
+      const readmePath = join9(newPath, "README.md");
+      if (existsSync10(readmePath)) {
+        const content = readFileSync8(readmePath, "utf-8");
+        const lines = content.split("\n");
+        let h1Index = -1;
+        for (let i = 0; i < lines.length; i++) {
+          if (lines[i].trim().startsWith("# ")) {
+            h1Index = i;
+            break;
+          }
+        }
+        if (h1Index !== -1) {
+          const newH1 = generateNoteTitle(
+            noteIndex,
+            newTitle.trim(),
+            REPO_NOTES_URL
+          );
+          lines[h1Index] = newH1;
+          writeFileSync7(readmePath, lines.join("\n"), "utf-8");
+          this.logger.success("\u2705 \u7B14\u8BB0\u6807\u9898\u5DF2\u66F4\u65B0");
+        } else {
+          this.logger.warn(
+            `\u26A0\uFE0F  \u7B14\u8BB0\u6807\u9898\u683C\u5F0F\u4E0D\u7B26\u5408\u89C4\u8303\uFF0C\u672A\u627E\u5230\u4E00\u7EA7\u6807\u9898\uFF0C\u8BF7\u624B\u52A8\u68C0\u67E5\u4FEE\u6B63: ${readmePath}`
+          );
+        }
+      }
+    } catch (error) {
+      this.logger.warn("\u26A0\uFE0F  \u66F4\u65B0\u7B14\u8BB0\u6807\u9898\u65F6\u51FA\u9519:", error);
+    }
+    try {
+      this.logger.info("\u6B63\u5728\u66F4\u65B0\u5168\u5C40 README.md \u548C sidebar.json...");
+      await this.readmeService.updateAllReadmes();
+      this.logger.success("\u2705 \u5168\u5C40\u6587\u4EF6\u5DF2\u66F4\u65B0");
+    } catch (error) {
+      this.logger.warn("\u26A0\uFE0F  \u6587\u4EF6\u5939\u91CD\u547D\u540D\u6210\u529F,\u4F46\u66F4\u65B0\u5168\u5C40\u6587\u4EF6\u65F6\u51FA\u9519:", error);
+    }
+  }
+};
+
+// commands/maintenance/SyncCoreCommand.ts
+var SyncCoreCommand = class extends BaseCommand {
+  constructor() {
+    super("sync-core");
+    this.syncCoreService = new SyncCoreService();
+  }
+  async run() {
+    await this.syncCoreService.syncToAllRepos();
+  }
+};
+
+// commands/maintenance/FixTimestampsCommand.ts
+var FixTimestampsCommand = class extends BaseCommand {
+  constructor() {
+    super("fix-timestamps");
+    this.timestampService = new TimestampService();
+  }
+  async run() {
+    this.logger.info("\u5F00\u59CB\u4FEE\u590D\u6240\u6709\u7B14\u8BB0\u7684\u65F6\u95F4\u6233...");
+    this.logger.info("\u{1F4CC} \u6B64\u64CD\u4F5C\u4F1A\u5C06\u6240\u6709\u65F6\u95F4\u6233\u66F4\u65B0\u4E3A git \u771F\u5B9E\u65F6\u95F4");
+    this.logger.info("");
+    const result = await this.timestampService.fixAllTimestamps(true);
+    this.logger.info("");
+    this.logger.info("\u{1F4CA} \u4FEE\u590D\u7EDF\u8BA1:");
+    this.logger.info(
+      `  - \u6839\u914D\u7F6E\u6587\u4EF6: ${result.rootConfigFixed ? "\u5DF2\u4FEE\u590D" : "\u65E0\u9700\u4FEE\u590D"}`
+    );
+    this.logger.info(`  - \u603B\u7B14\u8BB0\u6570: ${result.total}`);
+    this.logger.info(`  - \u5DF2\u4FEE\u590D: ${result.fixed}`);
+    this.logger.info(`  - \u8DF3\u8FC7: ${result.skipped}`);
+    this.logger.info("");
+    if (result.fixed > 0 || result.rootConfigFixed) {
+      this.logger.success(
+        `\u2705 \u6210\u529F\u4FEE\u590D ${result.fixed} \u4E2A\u7B14\u8BB0${result.rootConfigFixed ? " + \u6839\u914D\u7F6E\u6587\u4EF6" : ""}\u7684\u65F6\u95F4\u6233\uFF01`
+      );
+      this.logger.info("\u{1F4A1} \u63D0\u793A: \u8FD0\u884C pnpm tn:push \u63D0\u4EA4\u66F4\u6539");
+    } else {
+      this.logger.success("\u2705 \u6240\u6709\u65F6\u95F4\u6233\u5747\u5DF2\u6B63\u786E\uFF01");
+    }
+  }
+};
+
+// commands/misc/HelpCommand.ts
+var COMMAND_CATEGORIES = {
+  \u5F00\u53D1\u548C\u6784\u5EFA: [COMMAND_NAMES.DEV, COMMAND_NAMES.BUILD, COMMAND_NAMES.PREVIEW],
+  \u5185\u5BB9\u7BA1\u7406: [
+    COMMAND_NAMES.UPDATE,
+    COMMAND_NAMES.UPDATE_COMPLETED_COUNT,
+    COMMAND_NAMES.CREATE_NOTES
+  ],
+  "Git \u64CD\u4F5C": [COMMAND_NAMES.PUSH, COMMAND_NAMES.PULL, COMMAND_NAMES.SYNC],
+  \u5176\u4ED6: [
+    COMMAND_NAMES.SYNC_SCRIPTS,
+    COMMAND_NAMES.FIX_TIMESTAMPS,
+    COMMAND_NAMES.HELP
+  ]
+};
+var COMMAND_OPTIONS_INFO = {
+  [COMMAND_OPTIONS.ALL]: {
+    description: "\u6279\u91CF\u64CD\u4F5C\u6240\u6709\u77E5\u8BC6\u5E93",
+    applicableTo: "update/update-completed-count/push/pull/sync"
+  },
+  [COMMAND_OPTIONS.QUIET]: {
+    description: "\u9759\u9ED8\u6A21\u5F0F",
+    applicableTo: "update"
+  },
+  [COMMAND_OPTIONS.FORCE]: {
+    description: "\u5F3A\u5236\u63A8\u9001",
+    applicableTo: "push"
+  }
+};
+var HelpCommand = class extends BaseCommand {
+  constructor() {
+    super("help");
+    this.logger = createLogger("help", {
+      timestamp: false,
+      level: process.env.DEBUG ? 0 /* DEBUG */ : 1 /* INFO */
+    });
+  }
+  async run() {
+    this.logger.info("TNotes \u547D\u4EE4\u884C\u5DE5\u5177");
+    this.logger.info("");
+    this.logger.info("\u7528\u6CD5\uFF1Apnpm tn:<command> # \u63A8\u8350");
+    this.logger.info("\u6216\u8005\uFF1Anpx tsx ./.vitepress/tnotes/index.ts --<command>");
+    this.logger.info("");
+    this.logger.info("\u53EF\u7528\u547D\u4EE4\uFF1A");
+    this.logger.info("");
+    for (const [category, cmdNames] of Object.entries(COMMAND_CATEGORIES)) {
+      this.logger.info(`  ${category}:`);
+      for (const cmdName of cmdNames) {
+        const description = COMMAND_DESCRIPTIONS[cmdName];
+        const paddingLength = Math.max(25 - cmdName.length, 1);
+        const padding = " ".repeat(paddingLength);
+        this.logger.info(`    --${cmdName}${padding}${description}`);
+      }
+      this.logger.info("");
+    }
+    this.logger.info("\u793A\u4F8B\uFF1A");
+    this.logger.info("  npx tsx ./.vitepress/tnotes/index.ts --dev");
+    this.logger.info("  pnpm tn:build");
+    this.logger.info("  pnpm tn:create-notes     # \u6279\u91CF\u521B\u5EFA\u7B14\u8BB0");
+    this.logger.info("  pnpm tn:update");
+    this.logger.info("  pnpm tn:update --all     # \u66F4\u65B0\u6240\u6709\u77E5\u8BC6\u5E93");
+    this.logger.info(
+      "  pnpm tn:update-completed-count           # \u751F\u6210\u5F53\u524D\u77E5\u8BC6\u5E93\u6700\u8FD1 12 \u4E2A\u6708\u7684\u5B8C\u6210\u7B14\u8BB0\u6570\u91CF\u7EDF\u8BA1"
+    );
+    this.logger.info(
+      "  pnpm tn:update-completed-count --all     # \u751F\u6210\u6240\u6709\u77E5\u8BC6\u5E93\u6700\u8FD1 12 \u4E2A\u6708\u7684\u5B8C\u6210\u7B14\u8BB0\u6570\u91CF\u7EDF\u8BA1"
+    );
+    this.logger.info("  pnpm tn:push --all       # \u63A8\u9001\u6240\u6709\u77E5\u8BC6\u5E93");
+    this.logger.info("");
+    this.logger.info("\u53C2\u6570\uFF1A");
+    for (const [option, info] of Object.entries(COMMAND_OPTIONS_INFO)) {
+      const paddingLength = Math.max(13 - option.length, 1);
+      const padding = " ".repeat(paddingLength);
+      this.logger.info(
+        `  --${option}${padding}${info.description} (\u9002\u7528\u4E8E ${info.applicableTo})`
+      );
+    }
+    this.logger.info("");
+    this.logger.info("\u73AF\u5883\u53D8\u91CF\uFF1A");
+    this.logger.info("  DEBUG=1        \u542F\u7528\u8C03\u8BD5\u6A21\u5F0F\uFF0C\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7");
+    this.logger.info("");
+    this.logger.info("\u66F4\u591A\u4FE1\u606F\u8BF7\u67E5\u770B: .vitepress/tnotes/README.md");
+  }
+};
+
+// commands/registry.ts
+var commandFactories = {
+  dev: () => new DevCommand(),
+  build: () => new BuildCommand(),
+  preview: () => new PreviewCommand(),
+  update: () => new UpdateCommand(),
+  "update-completed-count": () => new UpdateCompletedCountCommand(),
+  push: () => new PushCommand(),
+  pull: () => new PullCommand(),
+  sync: () => new SyncCommand(),
+  "create-notes": () => new CreateNoteCommand(),
+  "sync-core": () => new SyncCoreCommand(),
+  "fix-timestamps": () => new FixTimestampsCommand(),
+  "update-note-config": () => new UpdateNoteConfigCommand(),
+  "rename-note": () => new RenameNoteCommand(),
+  help: () => new HelpCommand()
+};
+var commandCache = /* @__PURE__ */ new Map();
+function getCommand(name) {
+  if (!commandFactories[name]) return void 0;
+  if (!commandCache.has(name)) commandCache.set(name, commandFactories[name]());
+  return commandCache.get(name);
+}
+
+// index.ts
+(async () => {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const commandName = Object.keys(args).find(
+      (key) => key !== "_" && args[key] === true
+    );
+    const command = commandName ? getCommand(commandName) : null;
+    if (!command) {
+      const logger2 = createLogger("command-not-found", {
+        timestamp: false
+      });
+      console.log(`
+${"-".repeat(66)}
+`);
+      if (commandName) {
+        logger2.warn(`\u672A\u627E\u5230\u547D\u4EE4\uFF1A${commandName}`);
+        logger2.info(`\u8BF7\u68C0\u67E5\u547D\u4EE4\u540D\u662F\u5426\u6B63\u786E\uFF01`);
+      } else {
+        logger2.warn(`\u672A\u68C0\u6D4B\u5230\u547D\u4EE4\u540D\uFF0C\u8BF7\u68C0\u67E5\u547D\u4EE4\u8F93\u5165\u662F\u5426\u6B63\u786E`);
+        logger2.info(`\u793A\u4F8B\uFF1A`);
+        logger2.info(`pnpm tn:<\u547D\u4EE4\u540D>`);
+        logger2.info(`npx tsx ./.vitepress/tnotes/index.ts --<\u547D\u4EE4\u540D>`);
+      }
+      console.log(`
+${"-".repeat(66)}
+`);
+      const helpCommand = getCommand(COMMAND_NAMES.HELP);
+      if (helpCommand) {
+        console.log("\n\u6B63\u5728\u6267\u884C pnpm tn:help \u6253\u5370\u5E2E\u52A9\u4FE1\u606F...\n");
+        await helpCommand.execute();
+      }
+      return;
+    }
+    if (commandName === COMMAND_NAMES.UPDATE) {
+      const cmd = command;
+      if (args.quiet) cmd.setQuiet(true);
+      if (args.all) cmd.setUpdateAll(true);
+    } else if (commandName === COMMAND_NAMES.UPDATE_COMPLETED_COUNT) {
+      const cmd = command;
+      if (args.all) cmd.setUpdateAll(true);
+    } else if (commandName === COMMAND_NAMES.PUSH) {
+      const cmd = command;
+      if (args.force) cmd.setOptions({ force: true });
+      if (args.all) cmd.setPushAll(true);
+    } else if (commandName === COMMAND_NAMES.PULL) {
+      const cmd = command;
+      if (args.all) cmd.setPullAll(true);
+    } else if (commandName === COMMAND_NAMES.SYNC) {
+      const cmd = command;
+      if (args.all) cmd.setSyncAll(true);
+    }
+    await command.execute();
+  } catch (error) {
+    handleError(error, true);
+  }
+})();