@tnotesjs/core 0.1.2 → 0.1.4

package/dist/chunk-H2NACWVJ.js

@@ -0,0 +1,4631 @@
+import {
+  ConfigManager,
+  getConfigManager
+} from "./chunk-UIXF3LPU.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 tnotesjs/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"
+};
+
+// utils/errorHandler.ts
+var TNotesError = class _TNotesError extends Error {
+  constructor(message, code = "UNKNOWN" /* UNKNOWN */, context) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = "TNotesError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _TNotesError);
+    }
+  }
+};
+function handleError(error, exitOnError = false) {
+  if (error instanceof TNotesError) {
+    console.error(`\u274C TNotesError`);
+    console.error(`\u9519\u8BEF\u7801\uFF1A${error.code}`);
+    console.error(`\u9519\u8BEF\u4FE1\u606F\uFF1A${error.message}`);
+    if (error.context && Object.keys(error.context).length > 0) {
+      console.error("\u9519\u8BEF\u4E0A\u4E0B\u6587\u4FE1\u606F\uFF1A", error.context);
+    }
+    if (error.stack && process.env.DEBUG) {
+      console.error("\u9519\u8BEF\u5806\u6808\u4FE1\u606F\uFF1A", error.stack);
+    }
+  } else if (error instanceof Error) {
+    console.error(`\u274C Error`);
+    console.error(`\u9519\u8BEF\u4FE1\u606F\uFF1A${error.message}`);
+    if (error.stack && process.env.DEBUG) {
+      console.error("\u9519\u8BEF\u5806\u6808\u4FE1\u606F\uFF1A", error.stack);
+    }
+  } else {
+    console.error("\u274C \u672A\u77E5\u9519\u8BEF\uFF1A", error);
+  }
+  if (exitOnError) {
+    process.exit(1);
+  }
+}
+var createError = {
+  fileNotFound: (path2) => new TNotesError(`\u6587\u4EF6\u672A\u627E\u5230\uFF1A${path2}`, "FILE_NOT_FOUND" /* FILE_NOT_FOUND */, {
+    path: path2
+  }),
+  fileReadError: (path2, originalError) => new TNotesError(`\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25\uFF1A${path2}`, "FILE_READ_ERROR" /* FILE_READ_ERROR */, {
+    path: path2,
+    originalError: originalError?.message
+  }),
+  fileWriteError: (path2, originalError) => new TNotesError(`\u5199\u5165\u6587\u4EF6\u5931\u8D25\uFF1A${path2}`, "FILE_WRITE_ERROR" /* FILE_WRITE_ERROR */, {
+    path: path2,
+    originalError: originalError?.message
+  }),
+  gitNotRepo: (dir) => new TNotesError(`\u4E0D\u662F\u4E00\u4E2A Git \u4ED3\u5E93\uFF1A${dir}`, "GIT_NOT_REPO" /* GIT_NOT_REPO */, {
+    dir
+  }),
+  gitCommandFailed: (command, dir, originalError) => new TNotesError(`Git \u547D\u4EE4\u5931\u8D25\uFF1A${command}`, "GIT_COMMAND_FAILED" /* GIT_COMMAND_FAILED */, {
+    command,
+    dir,
+    originalError: originalError?.message
+  }),
+  noteIndexInvalid: (noteIndex) => new TNotesError(
+    `\u65E0\u6548\u7684\u7B14\u8BB0\u7D22\u5F15\uFF1A${noteIndex}`,
+    "NOTE_INDEX_INVALID" /* NOTE_INDEX_INVALID */,
+    {
+      noteIndex
+    }
+  ),
+  noteConfigInvalid: (notePath, reason) => new TNotesError(
+    `\u65E0\u6548\u7684\u7B14\u8BB0\u914D\u7F6E\uFF1A${notePath}`,
+    "NOTE_CONFIG_INVALID" /* NOTE_CONFIG_INVALID */,
+    { notePath, reason }
+  ),
+  configInvalid: (field, reason) => new TNotesError(`\u65E0\u6548\u7684\u914D\u7F6E\u5B57\u6BB5\uFF1A${field}`, "CONFIG_INVALID" /* CONFIG_INVALID */, {
+    field,
+    reason
+  }),
+  commandNotFound: (commandName) => new TNotesError(`\u672A\u627E\u5230\u547D\u4EE4\uFF1A${commandName}`, "COMMAND_NOT_FOUND" /* COMMAND_NOT_FOUND */, {
+    commandName
+  }),
+  commandFailed: (commandName, exitCode, originalError) => new TNotesError(`\u547D\u4EE4\u6267\u884C\u5931\u8D25\uFF1A${commandName}`, "COMMAND_FAILED" /* COMMAND_FAILED */, {
+    commandName,
+    exitCode,
+    originalError: originalError?.message
+  }),
+  serverStartFailed: (port2, originalError) => new TNotesError(
+    `\u542F\u52A8\u670D\u52A1\u5668\u5931\u8D25\uFF1A\u7AEF\u53E3 ${port2}`,
+    "SERVER_START_FAILED" /* SERVER_START_FAILED */,
+    { port: port2, originalError: originalError?.message }
+  ),
+  portInUse: (port2) => new TNotesError(`\u7AEF\u53E3 ${port2} \u5DF2\u88AB\u5360\u7528`, "PORT_IN_USE" /* PORT_IN_USE */, {
+    port: port2
+  })
+};
+
+// utils/logger.ts
+var Logger = class _Logger {
+  level;
+  prefix;
+  timestamp;
+  colors;
+  constructor(config2 = {}) {
+    this.level = config2.level ?? 1 /* INFO */;
+    this.prefix = config2.prefix ?? "";
+    this.timestamp = config2.timestamp ?? false;
+    this.colors = config2.colors ?? true;
+  }
+  /**
+   * 设置日志级别
+   */
+  setLevel(level) {
+    this.level = level;
+  }
+  /**
+   * 获取当前时间戳（精确到毫秒）
+   */
+  getTimestamp() {
+    if (!this.timestamp) return "";
+    const now = /* @__PURE__ */ new Date();
+    const hours = String(now.getHours()).padStart(2, "0");
+    const minutes = String(now.getMinutes()).padStart(2, "0");
+    const seconds = String(now.getSeconds()).padStart(2, "0");
+    const milliseconds = String(now.getMilliseconds()).padStart(3, "0");
+    return `[${hours}:${minutes}:${seconds}.${milliseconds}] `;
+  }
+  /**
+   * 格式化日志消息
+   */
+  formatMessage(message) {
+    const timestamp = this.getTimestamp();
+    const prefix = this.prefix ? `[${this.prefix}] ` : "";
+    return `${timestamp}${prefix}${message}`;
+  }
+  /**
+   * DEBUG 级别日志
+   */
+  debug(message, ...args) {
+    if (this.level <= 0 /* DEBUG */) {
+      console.log(`\u{1F41B} ${this.formatMessage(message)}`, ...args);
+    }
+  }
+  /**
+   * INFO 级别日志
+   */
+  info(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`\u2139\uFE0F  ${this.formatMessage(message)}`, ...args);
+    }
+  }
+  /**
+   * 成功日志（特殊的 INFO 级别）
+   */
+  success(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`\u2705 ${this.formatMessage(message)}`, ...args);
+    }
+  }
+  /**
+   * 警告日志
+   */
+  warn(message, ...args) {
+    if (this.level <= 2 /* WARN */) {
+      console.warn(`\u26A0\uFE0F  ${this.formatMessage(message)}`, ...args);
+    }
+  }
+  /**
+   * 错误日志
+   */
+  error(message, ...args) {
+    if (this.level <= 3 /* ERROR */) {
+      console.error(`\u274C ${this.formatMessage(message)}`, ...args);
+    }
+  }
+  /**
+   * 进度日志
+   */
+  progress(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`\u23F3 ${this.formatMessage(message)}`, ...args);
+    }
+  }
+  /**
+   * 启动日志
+   */
+  start(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`\u{1F680} ${this.formatMessage(message)}`, ...args);
+    }
+  }
+  /**
+   * 停止日志
+   */
+  stop(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`\u{1F6D1} ${this.formatMessage(message)}`, ...args);
+    }
+  }
+  /**
+   * 完成日志
+   */
+  done(message, duration, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      const durationStr = duration ? ` (${duration}ms)` : "";
+      console.log(`\u2728 ${this.formatMessage(message)}${durationStr}`, ...args);
+    }
+  }
+  /**
+   * 链接日志
+   */
+  link(message, url, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`\u{1F517} ${this.formatMessage(message)} ${url}`, ...args);
+    }
+  }
+  /**
+   * 文件操作日志
+   */
+  file(action, path2, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`\u{1F4C4} ${this.formatMessage(`${action}: ${path2}`)}`, ...args);
+    }
+  }
+  /**
+   * Git 操作日志
+   */
+  git(message, ...args) {
+    if (this.level <= 1 /* INFO */) {
+      console.log(`\u{1F4E6} ${this.formatMessage(message)}`, ...args);
+    }
+  }
+  /**
+   * 创建子 Logger
+   */
+  child(prefix) {
+    return new _Logger({
+      level: this.level,
+      prefix: this.prefix ? `${this.prefix}:${prefix}` : prefix,
+      timestamp: this.timestamp,
+      colors: this.colors
+    });
+  }
+  /**
+   * 执行函数并记录耗时
+   */
+  async time(label, fn) {
+    this.progress(`${label}...`);
+    const startTime = Date.now();
+    try {
+      const result = await fn();
+      const duration = Date.now() - startTime;
+      this.done(label, duration);
+      return result;
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      this.error(`${label} failed after ${duration}ms`);
+      throw error;
+    }
+  }
+};
+var logger = new Logger({
+  level: process.env.DEBUG ? 0 /* DEBUG */ : 1 /* INFO */,
+  timestamp: true,
+  // 启用时间戳（精确到毫秒）
+  colors: true
+});
+function createLogger(prefix, config2) {
+  return new Logger({
+    ...config2,
+    prefix
+  });
+}
+
+// utils/parseArgs.ts
+function parseArgs(args) {
+  const result = { _: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith("--") && arg.includes("=")) {
+      const eqIndex = arg.indexOf("=");
+      const key = arg.slice(2, eqIndex);
+      const value = arg.slice(eqIndex + 1);
+      result[key] = value;
+      continue;
+    }
+    if (arg.startsWith("--no-")) {
+      const key = arg.slice(5);
+      result[key] = false;
+      continue;
+    }
+    if (arg.startsWith("--")) {
+      const key = arg.slice(2);
+      const next = args[i + 1];
+      if (next !== void 0 && !next.startsWith("-")) {
+        if (next === "true") {
+          result[key] = true;
+          i++;
+        } else if (next === "false") {
+          result[key] = false;
+          i++;
+        } else {
+          result[key] = true;
+        }
+      } else {
+        result[key] = true;
+      }
+      continue;
+    }
+    if (arg.startsWith("-") && arg.length > 1 && !arg.startsWith("--")) {
+      const flags = arg.slice(1);
+      for (const flag of flags) {
+        result[flag] = true;
+      }
+      continue;
+    }
+    result._.push(arg);
+  }
+  return result;
+}
+
+// utils/file.ts
+import fs from "fs";
+async function ensureDirectory(dir) {
+  if (!fs.existsSync(dir)) {
+    await fs.promises.mkdir(dir, { recursive: true });
+  }
+}
+
+// utils/generateAnchor.ts
+import GithubSlugger from "github-slugger";
+var slugger = new GithubSlugger();
+var generateAnchor = (label) => {
+  slugger.reset();
+  return slugger.slug(label);
+};
+
+// utils/genHierarchicalSidebar.ts
+var genHierarchicalSidebar = (itemList, titles, titlesNotesCount, sidebarIsCollapsed) => {
+  const stack = [];
+  const root = [];
+  titles.forEach((title, i) => {
+    const match = title.match(/^#+/);
+    if (!match) return;
+    const level = match[0].length;
+    const text = title.replace(/^#+\s*/, "");
+    const noteItems = itemList.splice(0, titlesNotesCount[i]);
+    const node = {
+      text,
+      collapsed: sidebarIsCollapsed,
+      items: noteItems.length > 0 ? noteItems : []
+    };
+    if (i === 0 && level === 1) return;
+    while (stack.length > 0 && stack[stack.length - 1].level >= level) {
+      stack.pop();
+    }
+    if (stack.length === 0) {
+      root.push(node);
+    } else {
+      const parent = stack[stack.length - 1].node;
+      if (!parent.items) parent.items = [];
+      parent.items.push(node);
+    }
+    stack.push({ level, node });
+  });
+  return root;
+};
+
+// utils/getChangedIds.ts
+import path from "path";
+import { execSync } from "child_process";
+function getChangedIds() {
+  const changedFiles = execSync(
+    `git diff --name-only HEAD -- "notes/[0-9][0-9][0-9][0-9]*/README.md"`
+    // 根据当前仓库状态和最近一次提交之间的比较
+  ).toString().split(/\r?\n/).filter(Boolean).map((fp) => fp.replace(/^"|"$/g, "")).map((fp) => fp.split("/").join(path.sep));
+  const changedIds = changedFiles.map((fp) => {
+    const parts = fp.split(path.sep);
+    const dirName = parts.find((p, i) => parts[i - 1] === "notes");
+    return dirName?.slice(0, 4);
+  }).filter((id) => Boolean(id));
+  return new Set(changedIds);
+}
+
+// utils/getTargetDirs.ts
+import { readdirSync } from "fs";
+import { join } from "path";
+var getTargetDirs = (baseDir, prefix, excludeDirs = []) => {
+  try {
+    const entries = readdirSync(baseDir, { withFileTypes: true });
+    const targetDirs = entries.filter((entry) => entry.isDirectory() && entry.name.startsWith(prefix)).map((entry) => join(baseDir, entry.name)).filter((dir) => !excludeDirs.includes(dir));
+    return targetDirs;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    console.error(`\u8BFB\u53D6\u76EE\u5F55 ${baseDir} \u65F6\u51FA\u9519\uFF1A${errorMessage}`);
+    return [];
+  }
+};
+
+// utils/markdown.ts
+function createAddNumberToTitle() {
+  const titleNumbers = Array(7).fill(0);
+  return function addNumberToTitle(title) {
+    const match = title.match(
+      /^(\#+)\s*((\d+(\.\d*)?(\.\d*)?(\.\d*)?(\.\d*)?(\.\d*)?)\.\s*)?(.*)/
+    );
+    const plainTitle = match ? match[9].trim() : title.trim();
+    const level = title.indexOf(" ");
+    const baseLevel = 2;
+    if (level === 1) return [title, plainTitle];
+    for (let i = level + 1; i < titleNumbers.length; i++) titleNumbers[i] = 0;
+    titleNumbers[level] += 1;
+    const newNumber = titleNumbers.slice(baseLevel, level + 1).join(".");
+    const headerSymbol = title.slice(0, level).trim();
+    const newTitle = `${headerSymbol} ${newNumber}. ${plainTitle}`;
+    return [newTitle, plainTitle];
+  };
+}
+function generateToc(titles, baseLevel = 2, eol = "\n") {
+  const toc = titles.map((title) => {
+    const level = title.indexOf(" ");
+    const text = title.slice(level).trim();
+    const anchor = generateAnchor(text);
+    const indent = Math.max(0, (level - baseLevel) * 2);
+    return " ".repeat(indent) + `- [${text}](#${anchor})`;
+  }).join(eol);
+  return `${eol}${toc}${eol}`;
+}
+
+// utils/parseReadmeCompletedNotes.ts
+function parseReadmeCompletedNotes(content) {
+  const lines = content.split("\n");
+  const noteMap = /* @__PURE__ */ new Map();
+  const noteIndexRegex = /\[(\d{4})\./;
+  for (const line of lines) {
+    const match = line.match(noteIndexRegex);
+    if (!match) continue;
+    const noteIndex = match[1];
+    let completed;
+    if (line.includes("\u274C")) {
+      completed = false;
+    } else if (line.includes("\u23F0")) {
+      completed = false;
+    } else if (line.includes("\u2705")) {
+      completed = true;
+    } else if (line.trim().startsWith("- [ ]")) {
+      completed = false;
+    } else if (line.trim().startsWith("- [x]")) {
+      completed = true;
+    } else {
+      continue;
+    }
+    if (noteMap.has(noteIndex)) {
+      const existing = noteMap.get(noteIndex);
+      if (existing.completed !== completed) {
+        throw new Error(
+          `\u53D1\u73B0\u76F8\u540C\u7F16\u53F7 ${noteIndex} \u7684\u7B14\u8BB0\u6709\u4E0D\u540C\u7684\u5B8C\u6210\u72B6\u6001:
+  \u7B2C\u4E00\u6B21\u51FA\u73B0: ${existing.line}
+  \u7B2C\u4E8C\u6B21\u51FA\u73B0: ${line}`
+        );
+      }
+      continue;
+    }
+    noteMap.set(noteIndex, {
+      noteIndex,
+      completed,
+      line: line.trim()
+    });
+  }
+  const notes = Array.from(noteMap.values());
+  const completedCount = notes.filter((note) => note.completed).length;
+  const totalCount = notes.length;
+  return {
+    completedCount,
+    totalCount,
+    notes
+  };
+}
+
+// utils/portUtils.ts
+import { execSync as execSync2 } from "child_process";
+function isPortInUse(port2) {
+  try {
+    if (process.platform === "win32") {
+      const output = execSync2(
+        `netstat -ano | findstr :${port2} | findstr LISTENING`,
+        { encoding: "utf-8", stdio: "pipe" }
+      );
+      return output.trim().length > 0;
+    } else {
+      const output = execSync2(`lsof -i :${port2}`, {
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      return output.trim().length > 0;
+    }
+  } catch (error) {
+    return false;
+  }
+}
+function getPortPid(port2) {
+  try {
+    if (process.platform === "win32") {
+      const output = execSync2(`netstat -ano | findstr :${port2}`, {
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      const lines = output.trim().split("\n");
+      if (lines.length > 0) {
+        const match = lines[0].match(/\s+(\d+)\s*$/);
+        if (match) {
+          return parseInt(match[1]);
+        }
+      }
+    } else {
+      const output = execSync2(`lsof -t -i :${port2}`, {
+        encoding: "utf-8",
+        stdio: "pipe"
+      });
+      const pid = parseInt(output.trim());
+      if (!isNaN(pid)) {
+        return pid;
+      }
+    }
+  } catch (error) {
+  }
+  return null;
+}
+function killPortProcess(port2) {
+  const pid = getPortPid(port2);
+  if (!pid) {
+    return false;
+  }
+  try {
+    if (process.platform === "win32") {
+      execSync2(`taskkill /F /PID ${pid}`, { stdio: "pipe" });
+    } else {
+      execSync2(`kill -9 ${pid}`, { stdio: "pipe" });
+    }
+    logger.info(`\u5DF2\u7EC8\u6B62\u5360\u7528\u7AEF\u53E3 ${port2} \u7684\u8FDB\u7A0B (PID: ${pid})`);
+    return true;
+  } catch (error) {
+    logger.error(
+      `\u7EC8\u6B62\u8FDB\u7A0B\u5931\u8D25 (PID: ${pid}): ${error instanceof Error ? error.message : String(error)}`
+    );
+    return false;
+  }
+}
+async function waitForPort(port2, timeout = 5e3) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeout) {
+    if (!isPortInUse(port2)) {
+      return true;
+    }
+    await new Promise((resolve3) => setTimeout(resolve3, 100));
+  }
+  return false;
+}
+
+// core/NoteManager.ts
+import { existsSync, readFileSync, readdirSync as readdirSync2, writeFileSync } from "fs";
+import { join as join2 } from "path";
+
+// config/constants.ts
+import { resolve } from "path";
+var configManager = getConfigManager();
+var config = configManager.getAll();
+var {
+  author,
+  ignore_dirs,
+  menuItems,
+  port,
+  repoName,
+  sidebarShowNoteId,
+  socialLinks,
+  root_item
+} = config;
+var rootPath = configManager.getRootPath();
+var TNOTES_BASE_DIR = resolve(rootPath, "..");
+var TNOTES_CORE_DIR = resolve(TNOTES_BASE_DIR, "TNotes.core");
+var EN_WORDS_DIR = resolve(TNOTES_BASE_DIR, "TNotes.en-words");
+var ROOT_DIR_PATH = rootPath;
+var ROOT_README_PATH = resolve(ROOT_DIR_PATH, "README.md");
+var ROOT_CONFIG_PATH = resolve(ROOT_DIR_PATH, ".tnotes.json");
+var NOTES_DIR_PATH = resolve(ROOT_DIR_PATH, "notes");
+var VP_DIR_PATH = resolve(ROOT_DIR_PATH, ".vitepress");
+var PUBLIC_PATH = resolve(ROOT_DIR_PATH, "public");
+var GITHUB_DIR_PATH = resolve(ROOT_DIR_PATH, ".github");
+var GITHUB_DEPLOY_YML_PATH = resolve(
+  GITHUB_DIR_PATH,
+  "workflows",
+  "deploy.yml"
+);
+var VP_SIDEBAR_PATH = resolve(ROOT_DIR_PATH, "sidebar.json");
+var ROOT_PKG_PATH = resolve(ROOT_DIR_PATH, "package.json");
+var VSCODE_SETTINGS_PATH = resolve(
+  ROOT_DIR_PATH,
+  ".vscode",
+  "settings.json"
+);
+var VSCODE_TASKS_PATH = resolve(ROOT_DIR_PATH, ".vscode", "tasks.json");
+var EOL = "\n";
+var CONSTANTS = {
+  // 端口配置
+  DEFAULT_PORT: 5173,
+  // 笔记索引配置（文件夹前缀的 4 位数字）
+  NOTE_INDEX_LENGTH: 4,
+  NOTE_INDEX_PATTERN: /^\d{4}\./,
+  NOTE_INDEX_PREFIX_PATTERN: /^\d{4}/,
+  // Git 配置
+  DEFAULT_BRANCH: "main",
+  // 缓存配置
+  CACHE_TTL: 5e3,
+  // 终端输出颜色
+  COLORS: {
+    RESET: "\x1B[0m",
+    BRIGHT: "\x1B[1m",
+    DIM: "\x1B[2m",
+    RED: "\x1B[31m",
+    GREEN: "\x1B[32m",
+    YELLOW: "\x1B[33m",
+    BLUE: "\x1B[34m",
+    MAGENTA: "\x1B[35m",
+    CYAN: "\x1B[36m"
+  },
+  // Emoji
+  EMOJI: {
+    SUCCESS: "\u2705",
+    ERROR: "\u274C",
+    WARNING: "\u26A0\uFE0F",
+    INFO: "\u2139\uFE0F",
+    PROGRESS: "\u23F3",
+    ROCKET: "\u{1F680}",
+    STOP: "\u{1F6D1}",
+    SPARKLES: "\u2728",
+    LINK: "\u{1F517}",
+    FILE: "\u{1F4C4}",
+    GIT: "\u{1F4E6}",
+    DEBUG: "\u{1F41B}"
+  }
+};
+var NOTES_PATH = NOTES_DIR_PATH;
+var REPO_NOTES_URL = `https://github.com/${author}/${repoName}/tree/main/notes`;
+
+// core/NoteManager.ts
+var NoteManager = class _NoteManager {
+  static instance;
+  /** 笔记索引正则：4 位数字开头，后接小数点 */
+  static NOTE_INDEX_REGEX = /^(\d{4})\./;
+  constructor() {
+  }
+  /**
+   * 从文件夹名称或文本中提取笔记索引
+   *
+   * @param text - 要解析的文本（通常是文件夹名称）
+   * @returns 笔记索引（4 位数字字符串）或 null
+   *
+   * @example
+   * NoteManager.extractNoteIndex('0001. TNotes 简介') // '0001'
+   * NoteManager.extractNoteIndex('invalid-folder')     // null
+   */
+  static extractNoteIndex(text) {
+    const match = text.match(_NoteManager.NOTE_INDEX_REGEX);
+    return match ? match[1] : null;
+  }
+  /**
+   * 输出无效笔记名称的警告日志
+   *
+   * @param name - 无效的笔记名称
+   */
+  static warnInvalidNoteIndex(name) {
+    logger.warn(`\u65E0\u6548\u7684\u7B14\u8BB0\u540D: ${name}`);
+    logger.warn("\u7B14\u8BB0\u540D\u5FC5\u987B\u4EE5 4 \u4E2A\u6570\u5B57\u5F00\u5934");
+    logger.warn("\u8303\u56F4\uFF1A0001-9999");
+  }
+  static getInstance() {
+    if (!_NoteManager.instance) {
+      _NoteManager.instance = new _NoteManager();
+    }
+    return _NoteManager.instance;
+  }
+  /**
+   * 获取 notes 目录下所有合法的笔记目录名（已排序）
+   * 合法条件：是目录、不以 . 开头、以 4 位数字 + . 开头
+   */
+  getNoteDirs() {
+    if (!existsSync(NOTES_PATH)) return [];
+    return readdirSync2(NOTES_PATH, { withFileTypes: true }).filter(
+      (entry) => entry.isDirectory() && !entry.name.startsWith(".") && _NoteManager.NOTE_INDEX_REGEX.test(entry.name)
+    ).map((entry) => entry.name).sort();
+  }
+  /**
+   * 根据目录名构建单条 NoteInfo
+   * @returns NoteInfo 或 undefined（README 不存在时）
+   */
+  buildNoteInfo(dirName) {
+    const notePath = join2(NOTES_PATH, dirName);
+    const readmePath = join2(notePath, "README.md");
+    const configPath = join2(notePath, ".tnotes.json");
+    if (!existsSync(readmePath)) {
+      logger.warn(`README not found in note: ${dirName}`);
+      return void 0;
+    }
+    let config2;
+    if (existsSync(configPath)) {
+      config2 = this.validateAndFixConfig(configPath) || void 0;
+    }
+    return {
+      index: _NoteManager.extractNoteIndex(dirName),
+      path: notePath,
+      dirName,
+      readmePath,
+      configPath,
+      config: config2
+    };
+  }
+  /**
+   * 扫描所有笔记并校验数据完整性
+   *
+   * @returns 笔记信息数组
+   */
+  scanNotes() {
+    const noteDirs = this.getNoteDirs();
+    if (noteDirs.length === 0) {
+      logger.warn(`${NOTES_PATH} \u672A\u68C0\u6D4B\u5230\u7B14\u8BB0\u76EE\u5F55`);
+      return [];
+    }
+    const notes = [];
+    for (const dirName of noteDirs) {
+      const note = this.buildNoteInfo(dirName);
+      if (note) notes.push(note);
+    }
+    this.validateNotes(notes);
+    return notes;
+  }
+  /**
+   * 校验笔记数据完整性
+   *
+   * - 检查 noteIndex 冲突 + config id 缺失/重复
+   * - 任一检查失败则终止进程
+   */
+  validateNotes(notes) {
+    const errors = [];
+    const L1 = " ".repeat(3);
+    const L2 = " ".repeat(6);
+    const indexMap = this.buildNoteIndexMap(notes.map((n) => n.dirName));
+    for (const [index, dirNames] of indexMap.entries()) {
+      if (dirNames.length > 1) {
+        errors.push(`\u26A0\uFE0F  \u68C0\u6D4B\u5230\u91CD\u590D\u7684\u7B14\u8BB0\u7F16\u53F7\uFF1A`);
+        errors.push(`${L1}\u7D22\u5F15 ${index} \u88AB\u4EE5\u4E0B\u7B14\u8BB0\u91CD\u590D\u4F7F\u7528\uFF1A`);
+        dirNames.forEach((dirName) => errors.push(`${L2}- ${dirName}`));
+      }
+    }
+    const missingConfigId = [];
+    for (const note of notes) {
+      if (!note.config || !note.config.id) {
+        missingConfigId.push(note.dirName);
+      }
+    }
+    if (missingConfigId.length > 0) {
+      errors.push(`\u26A0\uFE0F  \u68C0\u6D4B\u5230\u7B14\u8BB0\u914D\u7F6E ID \u7F3A\u5931\uFF1A`);
+      missingConfigId.forEach((dirName) => errors.push(`${L2}- ${dirName}`));
+    }
+    const configIdMap = /* @__PURE__ */ new Map();
+    for (const note of notes) {
+      if (note.config?.id) {
+        if (!configIdMap.has(note.config.id))
+          configIdMap.set(note.config.id, []);
+        configIdMap.get(note.config.id).push(note.dirName);
+      }
+    }
+    for (const [configId, dirNames] of configIdMap.entries()) {
+      if (dirNames.length > 1) {
+        errors.push(`\u26A0\uFE0F  \u68C0\u6D4B\u5230\u91CD\u590D\u7684\u7B14\u8BB0\u914D\u7F6E ID\uFF1A`);
+        errors.push(`${L1}\u914D\u7F6E ID ${configId} \u88AB\u4EE5\u4E0B\u7B14\u8BB0\u91CD\u590D\u4F7F\u7528\uFF1A`);
+        dirNames.forEach((dirName) => errors.push(`${L2}- ${dirName}`));
+      }
+    }
+    if (errors.length > 0) {
+      for (const line of errors) {
+        logger.error(line);
+      }
+      logger.error("\n\n\u8BF7\u4FEE\u590D\u4E0A\u8FF0\u95EE\u9898\u540E\u91CD\u65B0\u542F\u52A8\u670D\u52A1\u3002\n\n");
+      process.exit(1);
+    }
+  }
+  /**
+   * 按 4 位数字编号对目录名分组
+   * @param dirNames - 目录名数组
+   * @returns 编号 -> 目录名数组 的映射
+   */
+  buildNoteIndexMap(dirNames) {
+    const indexMap = /* @__PURE__ */ new Map();
+    for (const name of dirNames) {
+      const index = _NoteManager.extractNoteIndex(name);
+      if (!indexMap.has(index)) indexMap.set(index, []);
+      indexMap.get(index).push(name);
+    }
+    return indexMap;
+  }
+  /** 配置字段顺序 */
+  static FIELD_ORDER = [
+    "bilibili",
+    "tnotes",
+    "yuque",
+    "done",
+    "category",
+    "enableDiscussions",
+    "description",
+    "id",
+    "created_at",
+    "updated_at"
+  ];
+  /** 默认配置字段 */
+  static DEFAULT_CONFIG_FIELDS = {
+    bilibili: [],
+    tnotes: [],
+    yuque: [],
+    done: false,
+    enableDiscussions: false,
+    description: ""
+  };
+  /** 必需字段（不能缺失） */
+  static REQUIRED_FIELDS = ["id"];
+  /**
+   * 验证并修复配置文件
+   * @param configPath - 配置文件路径
+   * @returns 修复后的配置对象，失败时返回 null
+   */
+  validateAndFixConfig(configPath) {
+    const configContent = readFileSync(configPath, "utf-8");
+    let config2;
+    try {
+      config2 = JSON.parse(configContent);
+    } catch (error) {
+      logger.error(`\u914D\u7F6E\u6587\u4EF6 JSON \u89E3\u6790\u5931\u8D25: ${configPath}`, error);
+      return null;
+    }
+    let needsUpdate = false;
+    for (const field of _NoteManager.REQUIRED_FIELDS) {
+      if (!config2[field]) {
+        return null;
+      }
+    }
+    for (const [key, defaultValue] of Object.entries(
+      _NoteManager.DEFAULT_CONFIG_FIELDS
+    )) {
+      if (!(key in config2)) {
+        ;
+        config2[key] = defaultValue;
+        needsUpdate = true;
+        logger.info(`\u8865\u5145\u7F3A\u5931\u5B57\u6BB5 "${key}": ${configPath}`);
+      }
+    }
+    const now = Date.now();
+    if (!config2.created_at) {
+      config2.created_at = now;
+      needsUpdate = true;
+      logger.info(
+        `\u68C0\u6D4B\u5230 ${configPath} \u7F3A\u5931  created_at \u5B57\u6BB5\uFF0C\u8BF7\u6267\u884C tn:fix-timestamps \u6821\u51C6\u4E3A\u7B14\u8BB0\u9996\u6B21 git commit \u7684\u65F6\u95F4\uFF09`
+      );
+    }
+    if (!config2.updated_at) {
+      config2.updated_at = now;
+      needsUpdate = true;
+      logger.info(
+        `\u68C0\u6D4B\u5230 ${configPath} \u7F3A\u5931  updated_at \u5B57\u6BB5\uFF0C\u8BF7\u6267\u884C tn:fix-timestamps \u6821\u51C6\u4E3A\u7B14\u8BB0\u6700\u540E\u4E00\u6B21 git commit \u7684\u65F6\u95F4\uFF09`
+      );
+    }
+    const sortedConfig = this.sortConfigKeys(config2);
+    if (needsUpdate) {
+      this.writeNoteConfig(configPath, sortedConfig);
+      logger.info(`\u914D\u7F6E\u6587\u4EF6\u5DF2\u4FEE\u590D: ${configPath}`);
+    }
+    return sortedConfig;
+  }
+  /**
+   * 按指定顺序排序配置对象的键
+   */
+  sortConfigKeys(config2) {
+    const configRecord = config2;
+    const sorted = {};
+    for (const key of _NoteManager.FIELD_ORDER) {
+      if (key in config2) {
+        sorted[key] = configRecord[key];
+      }
+    }
+    for (const key of Object.keys(config2)) {
+      if (!(key in sorted)) {
+        sorted[key] = configRecord[key];
+      }
+    }
+    return sorted;
+  }
+  /**
+   * 序列化 NoteConfig 为格式化的 JSON 字符串
+   * 保持字段顺序，使用 2 空格缩进，末尾含换行符
+   */
+  serializeNoteConfig(config2) {
+    const sorted = this.sortConfigKeys(config2);
+    return JSON.stringify(sorted, null, 2) + "\n";
+  }
+  /**
+   * 统一写入笔记配置文件
+   * @param configPath - 配置文件路径
+   * @param config - 笔记配置
+   */
+  writeNoteConfig(configPath, config2) {
+    writeFileSync(configPath, this.serializeNoteConfig(config2), "utf-8");
+  }
+  /**
+   * 验证笔记配置对象的结构合法性
+   * @param config - 笔记配置
+   * @returns 是否有效
+   */
+  validateConfig(config2) {
+    if (!config2.id) {
+      logger.error("Note config missing id");
+      return false;
+    }
+    if (!Array.isArray(config2.bilibili)) {
+      logger.error(`Invalid bilibili config in note: ${config2.id}`);
+      return false;
+    }
+    if (!Array.isArray(config2.tnotes)) {
+      logger.error(`Invalid tnotes config in note: ${config2.id}`);
+      return false;
+    }
+    if (!Array.isArray(config2.yuque)) {
+      logger.error(`Invalid yuque config in note: ${config2.id}`);
+      return false;
+    }
+    if (typeof config2.done !== "boolean") {
+      logger.error(`Invalid done status in note: ${config2.id}`);
+      return false;
+    }
+    if (typeof config2.enableDiscussions !== "boolean") {
+      logger.error(`Invalid enableDiscussions status in note: ${config2.id}`);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * 更新笔记配置
+   * @param noteInfo - 笔记信息
+   * @param config - 新的配置
+   */
+  updateNoteConfig(noteInfo, config2) {
+    if (!this.validateConfig(config2)) {
+      throw new Error(`Invalid config for note: ${noteInfo.dirName}`);
+    }
+    config2.updated_at = Date.now();
+    this.writeNoteConfig(noteInfo.configPath, config2);
+    logger.info(`Updated config for note: ${noteInfo.dirName}`);
+  }
+  /**
+   * 获取笔记信息（通过索引）- 直接查找不扫描所有笔记
+   * @param noteIndex - 笔记索引
+   * @returns 笔记信息，未找到时返回 undefined
+   */
+  getNoteByIndex(noteIndex) {
+    const noteDirs = this.getNoteDirs();
+    for (const dirName of noteDirs) {
+      if (_NoteManager.extractNoteIndex(dirName) === noteIndex) {
+        return this.buildNoteInfo(dirName);
+      }
+    }
+    return void 0;
+  }
+};
+
+// utils/readmeHelpers.ts
+var NOTE_LINE_REGEX = /^( *)- \[.\] \[(\d{4}\. .+?)\]/;
+function parseNoteLine(line) {
+  const noteMatch = line.match(NOTE_LINE_REGEX);
+  if (!noteMatch) {
+    return {
+      isMatch: false,
+      noteIndex: null
+    };
+  }
+  const [, , text] = noteMatch;
+  const noteIndex = NoteManager.extractNoteIndex(text);
+  return {
+    isMatch: true,
+    noteIndex
+  };
+}
+function buildNoteLink(note, repoOwner, repoName2) {
+  const encodedDirName = encodeURIComponent(note.dirName);
+  return `https://github.com/${repoOwner}/${repoName2}/tree/main/notes/${encodedDirName}/README.md`;
+}
+function updateNoteStatus(note) {
+  let status = " ";
+  let deprecatedMark = "";
+  if (note.config) {
+    if (note.config.done) {
+      status = "x";
+    }
+  }
+  return { status, deprecatedMark };
+}
+function buildNoteLineMarkdown(note, repoOwner, repoName2) {
+  const url = buildNoteLink(note, repoOwner, repoName2);
+  const { status, deprecatedMark } = updateNoteStatus(note);
+  return `- [${status}] [${note.dirName}](${url})${deprecatedMark}`;
+}
+function isNoteLine(line) {
+  return NOTE_LINE_REGEX.test(line);
+}
+function mergeConsecutiveEmptyLines(lines) {
+  const result = [];
+  let previousLineIsEmpty = false;
+  for (const line of lines) {
+    const isCurrentLineEmpty = line === "";
+    if (isCurrentLineEmpty) {
+      if (!previousLineIsEmpty) {
+        result.push(line);
+        previousLineIsEmpty = true;
+      }
+    } else {
+      result.push(line);
+      previousLineIsEmpty = false;
+    }
+  }
+  return result;
+}
+function removeEmptyLinesBetweenNotes(lines) {
+  const result = [];
+  for (let i = 0; i < lines.length; i++) {
+    const currentLine = lines[i];
+    const prevLine = i > 0 ? lines[i - 1] : null;
+    const nextLine = i < lines.length - 1 ? lines[i + 1] : null;
+    if (currentLine === "" && prevLine && nextLine) {
+      const isPrevLineNote = isNoteLine(prevLine);
+      const isNextLineNote = isNoteLine(nextLine);
+      if (isPrevLineNote && isNextLineNote) {
+        continue;
+      }
+    }
+    result.push(currentLine);
+  }
+  return result;
+}
+function processEmptyLines(lines) {
+  const stepOne = mergeConsecutiveEmptyLines(lines);
+  const stepTwo = removeEmptyLinesBetweenNotes(stepOne);
+  return stepTwo;
+}
+
+// utils/runCommand.ts
+import { exec } from "child_process";
+async function runCommand(command, dir) {
+  return new Promise((resolve3, reject) => {
+    exec(command, { cwd: dir }, (error, stdout, stderr) => {
+      if (error) {
+        console.error(`\u5904\u7406 ${dir} \u65F6\u51FA\u9519\uFF1A${stderr}`);
+        reject(error);
+      } else {
+        resolve3(stdout.trim());
+      }
+    });
+  });
+}
+
+// utils/syncRepo.ts
+async function pushAllRepos(options) {
+  const {
+    parallel = true,
+    continueOnError = true,
+    force = false
+  } = options || {};
+  const targetDirs = getTargetDirs(TNOTES_BASE_DIR, "TNotes.", [EN_WORDS_DIR, TNOTES_CORE_DIR]);
+  logger.info(`\u6B63\u5728\u63A8\u9001 ${targetDirs.length} \u4E2A\u4ED3\u5E93...`);
+  if (force) {
+    logger.warn("\u4F7F\u7528\u5F3A\u5236\u63A8\u9001\u6A21\u5F0F");
+  }
+  const results = [];
+  const pushCmd = force ? "pnpm tn:push --force" : "pnpm tn:push";
+  if (parallel) {
+    const promises = targetDirs.map(async (dir, index) => {
+      try {
+        await runCommand(pushCmd, dir);
+        process.stdout.write(`\r  \u8FDB\u5EA6: ~${index + 1}/${targetDirs.length}`);
+        return { dir, success: true };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { dir, success: false, error: errorMessage };
+      }
+    });
+    results.push(...await Promise.all(promises));
+    console.log();
+  } else {
+    for (let i = 0; i < targetDirs.length; i++) {
+      const dir = targetDirs[i];
+      try {
+        await runCommand(pushCmd, dir);
+        process.stdout.write(`\r  \u8FDB\u5EA6: ${i + 1}/${targetDirs.length}`);
+        results.push({ dir, success: true });
+      } catch (error) {
+        process.stdout.write(`\r  \u8FDB\u5EA6: ${i + 1}/${targetDirs.length}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        results.push({ dir, success: false, error: errorMessage });
+        if (!continueOnError) {
+          console.log();
+          throw error;
+        }
+      }
+    }
+    console.log();
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.length - successCount;
+  if (failCount === 0) {
+    logger.success(`\u63A8\u9001\u5B8C\u6210: ${successCount}/${results.length} \u4E2A\u4ED3\u5E93\u6210\u529F`);
+  } else {
+    logger.warn(
+      `\u63A8\u9001\u5B8C\u6210: ${successCount} \u6210\u529F, ${failCount} \u5931\u8D25 (\u5171 ${results.length} \u4E2A)`
+    );
+    console.log("\n\u5931\u8D25\u7684\u4ED3\u5E93:");
+    results.filter((r) => !r.success).forEach((r, index) => {
+      const repoName2 = r.dir.split("\\").pop() || r.dir;
+      console.log(`  ${index + 1}. ${repoName2}`);
+      console.log(`     \u9519\u8BEF: ${r.error}`);
+    });
+  }
+}
+async function pullAllRepos(options) {
+  const { parallel = true, continueOnError = true } = options || {};
+  const targetDirs = getTargetDirs(TNOTES_BASE_DIR, "TNotes.", [EN_WORDS_DIR, TNOTES_CORE_DIR]);
+  logger.info(`\u6B63\u5728\u62C9\u53D6 ${targetDirs.length} \u4E2A\u4ED3\u5E93...`);
+  const results = [];
+  if (parallel) {
+    const promises = targetDirs.map(async (dir, index) => {
+      try {
+        await runCommand("pnpm tn:pull", dir);
+        process.stdout.write(`\r  \u8FDB\u5EA6: ~${index + 1}/${targetDirs.length}`);
+        return { dir, success: true };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { dir, success: false, error: errorMessage };
+      }
+    });
+    results.push(...await Promise.all(promises));
+    console.log();
+  } else {
+    for (let i = 0; i < targetDirs.length; i++) {
+      const dir = targetDirs[i];
+      try {
+        await runCommand("pnpm tn:pull", dir);
+        process.stdout.write(`\r  \u8FDB\u5EA6: ${i + 1}/${targetDirs.length}`);
+        results.push({ dir, success: true });
+      } catch (error) {
+        process.stdout.write(`\r  \u8FDB\u5EA6: ${i + 1}/${targetDirs.length}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        results.push({ dir, success: false, error: errorMessage });
+        if (!continueOnError) {
+          console.log();
+          throw error;
+        }
+      }
+    }
+    console.log();
+  }
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.length - successCount;
+  if (failCount === 0) {
+    logger.success(`\u62C9\u53D6\u5B8C\u6210: ${successCount}/${results.length} \u4E2A\u4ED3\u5E93\u6210\u529F`);
+  } else {
+    logger.warn(
+      `\u62C9\u53D6\u5B8C\u6210: ${successCount} \u6210\u529F, ${failCount} \u5931\u8D25 (\u5171 ${results.length} \u4E2A)`
+    );
+    console.log("\n\u5931\u8D25\u7684\u4ED3\u5E93:");
+    results.filter((r) => !r.success).forEach((r, index) => {
+      const repoName2 = r.dir.split("\\").pop() || r.dir;
+      console.log(`  ${index + 1}. ${repoName2}`);
+      console.log(`     \u9519\u8BEF: ${r.error}`);
+    });
+  }
+}
+async function syncAllRepos(options) {
+  const { parallel = true, continueOnError = true } = options || {};
+  const targetDirs = getTargetDirs(TNOTES_BASE_DIR, "TNotes.", [EN_WORDS_DIR, TNOTES_CORE_DIR]);
+  logger.info(`\u6B63\u5728\u540C\u6B65 ${targetDirs.length} \u4E2A\u4ED3\u5E93...`);
+  const results = [];
+  if (parallel) {
+    const promises = targetDirs.map(async (dir, index) => {
+      try {
+        await runCommand("pnpm tn:sync", dir);
+        process.stdout.write(`\r  \u8FDB\u5EA6: ~${index + 1}/${targetDirs.length}`);
+        return { dir, success: true };
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return { dir, success: false, error: errorMessage };
+      }
+    });
+    results.push(...await Promise.all(promises));
+  } else {
+    for (let i = 0; i < targetDirs.length; i++) {
+      const dir = targetDirs[i];
+      try {
+        await runCommand("pnpm tn:sync", dir);
+        process.stdout.write(`\r  \u8FDB\u5EA6: ${i + 1}/${targetDirs.length}`);
+        results.push({ dir, success: true });
+      } catch (error) {
+        process.stdout.write(`\r  \u8FDB\u5EA6: ${i + 1}/${targetDirs.length}`);
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        results.push({ dir, success: false, error: errorMessage });
+        if (!continueOnError) {
+          throw error;
+        }
+      }
+    }
+  }
+  console.log();
+  const successCount = results.filter((r) => r.success).length;
+  const failCount = results.length - successCount;
+  if (failCount === 0) {
+    logger.success(`\u540C\u6B65\u5B8C\u6210: ${successCount}/${results.length} \u4E2A\u4ED3\u5E93\u6210\u529F`);
+  } else {
+    logger.warn(
+      `\u540C\u6B65\u5B8C\u6210: ${successCount} \u6210\u529F, ${failCount} \u5931\u8D25 (\u5171 ${results.length} \u4E2A)`
+    );
+    console.log("\n\u5931\u8D25\u7684\u4ED3\u5E93:");
+    results.filter((r) => !r.success).forEach((r, index) => {
+      const repoName2 = r.dir.split("\\").pop() || r.dir;
+      console.log(`  ${index + 1}. ${repoName2}`);
+      console.log(`     \u9519\u8BEF: ${r.error}`);
+    });
+  }
+}
+
+// utils/validators.ts
+var INVALID_FILENAME_CHARS = /[<>:"/\\|?*\x00-\x1F]/;
+var WINDOWS_RESERVED_NAMES = /* @__PURE__ */ new Set([
+  "CON",
+  "PRN",
+  "AUX",
+  "NUL",
+  "COM1",
+  "COM2",
+  "COM3",
+  "COM4",
+  "COM5",
+  "COM6",
+  "COM7",
+  "COM8",
+  "COM9",
+  "LPT1",
+  "LPT2",
+  "LPT3",
+  "LPT4",
+  "LPT5",
+  "LPT6",
+  "LPT7",
+  "LPT8",
+  "LPT9"
+]);
+function validateNoteTitle(title) {
+  if (!title || title.trim().length === 0) {
+    return { valid: false, error: "\u6807\u9898\u4E0D\u80FD\u4E3A\u7A7A" };
+  }
+  const trimmedTitle = title.trim();
+  if (trimmedTitle.length > 200) {
+    return { valid: false, error: "\u6807\u9898\u8FC7\u957F(\u6700\u591A200\u4E2A\u5B57\u7B26)" };
+  }
+  if (INVALID_FILENAME_CHARS.test(trimmedTitle)) {
+    return {
+      valid: false,
+      error: '\u6807\u9898\u5305\u542B\u975E\u6CD5\u5B57\u7B26(\u4E0D\u5141\u8BB8: < > : " / \\ | ? *)'
+    };
+  }
+  if (/^[.\s]|[.\s]$/.test(trimmedTitle)) {
+    return {
+      valid: false,
+      error: "\u6807\u9898\u4E0D\u80FD\u4EE5\u70B9\u6216\u7A7A\u683C\u5F00\u5934/\u7ED3\u5C3E"
+    };
+  }
+  const upperTitle = trimmedTitle.toUpperCase();
+  if (WINDOWS_RESERVED_NAMES.has(upperTitle)) {
+    return {
+      valid: false,
+      error: `"${trimmedTitle}" \u662F Windows \u7CFB\u7EDF\u4FDD\u7559\u540D\u79F0`
+    };
+  }
+  const baseName = trimmedTitle.split(".")[0].toUpperCase();
+  if (WINDOWS_RESERVED_NAMES.has(baseName)) {
+    return {
+      valid: false,
+      error: `"${trimmedTitle}" \u5305\u542B Windows \u7CFB\u7EDF\u4FDD\u7559\u540D\u79F0`
+    };
+  }
+  return { valid: true };
+}
+
+// core/NoteIndexCache.ts
+import { join as join3 } from "path";
+var NoteIndexCache = class _NoteIndexCache {
+  static instance = null;
+  /** noteIndex -> NoteIndexItem 的映射 */
+  byNoteIndex = /* @__PURE__ */ new Map();
+  /** configId (UUID) -> noteIndex 的映射，用于快速反向查询 */
+  byConfigId = /* @__PURE__ */ new Map();
+  /** 是否已完成初始化 */
+  _initialized = false;
+  constructor() {
+  }
+  /**
+   * 获取单例实例
+   */
+  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 = join3(NOTES_PATH, item.folderName);
+      result.push({
+        index: item.noteIndex,
+        path: notePath,
+        dirName: item.folderName,
+        readmePath: join3(notePath, "README.md"),
+        configPath: join3(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}`);
+  }
+};
+
+// core/ReadmeGenerator.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, existsSync as existsSync2 } 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, repoName2) {
+    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.${repoName2}.${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((repoName3) => {
+          tnotesTOCItems.push(
+            `  - [TNotes.${repoName3}](https://tnotesjs.github.io/TNotes.${repoName3}/)`
+          );
+        });
+      }
+      if (noteConfig.yuque.length > 0) {
+        noteConfig.yuque.forEach((slug, i) => {
+          yuqueTOCItems.push(
+            `  - [TNotes.yuque.${repoName2.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 {
+  tocGenerator;
+  configManager;
+  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 repoName2 = this.configManager.get("repoName");
+    this.tocGenerator.updateNoteToc(
+      noteInfo.index,
+      lines,
+      noteInfo.config,
+      repoName2
+    );
+    const updatedContent = lines.join(EOL);
+    writeFileSync2(noteInfo.readmePath, updatedContent, "utf-8");
+  }
+  /**
+   * 更新首页 README
+   * 更新笔记链接的状态标记（[x] 或 [ ]），同时更新 TOC 区域
+   * @param notes - 笔记信息数组
+   * @param homeReadmePath - 首页 README 路径
+   */
+  updateHomeReadme(notes, homeReadmePath) {
+    if (!existsSync2(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 repoName2 = 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, repoName2);
+        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, repoName2);
+        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);
+    writeFileSync2(homeReadmePath, updatedContent, "utf-8");
+    logger.info("\u5DF2\u66F4\u65B0\u9996\u9875 README");
+  }
+};
+
+// core/GitManager.ts
+import { resolve as resolve2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+var GitManager = class {
+  logger;
+  dir;
+  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 path2 = line.substring(3);
+      path2 = path2.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: path2, 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 existsSync3(resolve2(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 = resolve2(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 {
+  processes = /* @__PURE__ */ new Map();
+  logger;
+  constructor() {
+    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();
+  }
+};
+
+// commands/BaseCommand.ts
+var BaseCommand = class {
+  constructor(name) {
+    this.name = name;
+    this.logger = logger.child(name);
+  }
+  logger;
+  options = {};
+  /** 命令描述（从静态配置读取） */
+  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 as existsSync4, readFileSync as readFileSync3, readdirSync as readdirSync3, statSync } from "fs";
+import { createHash } from "crypto";
+import { join as join4 } from "path";
+var WatchState = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  /** 文件哈希缓存 */
+  fileHashes = /* @__PURE__ */ new Map();
+  /** 笔记目录缓存 */
+  noteDirCache = /* @__PURE__ */ new Set();
+  /** 笔记配置缓存 */
+  configCache = /* @__PURE__ */ new Map();
+  /**
+   * 获取指定文件的 MD5 哈希值，若文件不存在或读取失败返回 null
+   *
+   * @param filePath 文件路径
+   * @returns 文件哈希
+   */
+  getFileHash(filePath) {
+    try {
+      if (!existsSync4(filePath)) return null;
+      const content = readFileSync3(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 = join4(this.config.notesDir, noteDirName, "README.md");
+    const configPath = join4(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 (!existsSync4(configPath)) return null;
+      const content = readFileSync3(configPath, "utf-8");
+      const config2 = JSON.parse(content);
+      return {
+        done: Boolean(config2.done),
+        enableDiscussions: Boolean(config2.enableDiscussions),
+        description: config2.description || ""
+      };
+    } catch (error) {
+      this.config.logger.error(`[\u8BFB\u53D6\u914D\u7F6E\u5FEB\u7167] ${error}`);
+      return null;
+    }
+  }
+  /**
+   * 从磁盘初始化监听状态缓存：
+   * 遍历笔记根目录下的所有子目录，将每个笔记目录的 README.md 和 .tnotes.json
+   * 的哈希值及配置快照加载到缓存中。
+   */
+  initializeFromDisk() {
+    try {
+      const noteDirs = readdirSync3(this.config.notesDir);
+      this.clearAll();
+      for (const noteDir of noteDirs) {
+        const noteDirPath = join4(this.config.notesDir, noteDir);
+        if (!statSync(noteDirPath).isDirectory()) continue;
+        this.noteDirCache.add(noteDir);
+        const readmePath = join4(noteDirPath, "README.md");
+        const readmeHash = this.getFileHash(readmePath);
+        if (readmeHash) this.fileHashes.set(readmePath, readmeHash);
+        const configPath = join4(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(config2) {
+    this.config = config2;
+    this.debounceMs = config2.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    this.batchWindowMs = config2.batchWindowMs ?? DEFAULT_BATCH_WINDOW_MS;
+    this.batchThreshold = config2.batchThreshold ?? DEFAULT_BATCH_THRESHOLD;
+    this.batchBufferMs = config2.batchBufferMs ?? DEFAULT_BATCH_BUFFER_MS;
+  }
+  /** 待处理的文件变更事件队列 */
+  pendingEvents = /* @__PURE__ */ new Map();
+  /** 防抖定时器 */
+  updateTimer = null;
+  /** 批量更新恢复定时器 */
+  batchResumeTimer = null;
+  /** 记录最近的变更时间戳 */
+  recentChanges = [];
+  /** 标记是否正在更新，避免循环触发 - 类似一把更新行为锁 */
+  isUpdating = false;
+  debounceMs;
+  batchWindowMs;
+  batchThreshold;
+  batchBufferMs;
+  /**
+   * 设置更新状态锁，用于防止在执行耗时更新操作时被新的文件变更事件打断
+   *
+   * @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 existsSync5 } from "fs";
+import { join as join5 } from "path";
+var FOLDER_RENAME_DETECT_WINDOW_MS = 500;
+var RenameDetector = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  /** 待处理的文件夹重命名 */
+  pendingFolderRename = null;
+  /** 文件夹重命名检测定时器 */
+  folderRenameTimer = null;
+  handleFsRename(folderName) {
+    const { notesDir, dirCache, logger: logger2, onDelete, onRename } = this.config;
+    const folderPath = join5(notesDir, folderName);
+    const folderExists = existsSync5(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(config2) {
+    this.config = config2;
+  }
+  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(config2) {
+    this.config = config2;
+  }
+  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(config2) {
+    this.config = config2;
+  }
+  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 existsSync6, promises as fsPromises } from "fs";
+import { join as join6 } from "path";
+var RENAME_REVERT_DELAY_MS = 2e3;
+var DELETE_REINIT_DELAY_MS = 1e3;
+var UPDATE_UNLOCK_DELAY_MS = 500;
+var FolderChangeHandler = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  /** 活跃的定时器 ID 集合，用于统一清理 */
+  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 = join6(notesDir, oldName);
+      const newPath = join6(notesDir, newName);
+      if (existsSync6(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 join7, sep } from "path";
+var FsWatcherAdapter = class {
+  constructor(config2) {
+    this.config = config2;
+  }
+  /** 文件系统监听器实例 */
+  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 = join7(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)
+    };
+  }
+};
+
+// services/readme/service.ts
+import {
+  existsSync as existsSync7,
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync3,
+  promises as fsPromises2
+} from "fs";
+var ReadmeService = class _ReadmeService {
+  static instance;
+  noteManager;
+  readmeGenerator;
+  configManager;
+  noteIndexCache;
+  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 (!existsSync7(ROOT_README_PATH)) {
+      logger.error("\u672A\u627E\u5230\u9996\u9875 README\uFF0C\u65E0\u6CD5\u751F\u6210\u4FA7\u8FB9\u680F");
+      return;
+    }
+    const content = readFileSync4(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 sidebarShowNoteId2 = this.configManager.get("sidebarShowNoteId");
+        let displayText = note.dirName;
+        if (!sidebarShowNoteId2) {
+          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
+    );
+    writeFileSync3(
+      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 repoName2 = 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, repoName2);
+        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 repoName2 = this.configManager.get("repoName");
+    const tempNoteInfo = {
+      index: noteIndex,
+      dirName: item.folderName,
+      path: "",
+      readmePath: "",
+      configPath: "",
+      config: item.noteConfig
+    };
+    const noteLine = buildNoteLineMarkdown(tempNoteInfo, repoOwner, repoName2);
+    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 writeFileSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join8 } 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 {
+  static instance;
+  noteManager;
+  noteIndexCache;
+  ignoredConfigPaths = /* @__PURE__ */ new Set();
+  constructor() {
+    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 = join8(NOTES_PATH, dirName);
+    await ensureDirectory(notePath);
+    const readmePath = join8(notePath, "README.md");
+    const noteTitle = generateNoteTitle(noteIndex, title, REPO_NOTES_URL);
+    const readmeContent = noteTitle + "\n" + NEW_NOTES_README_MD_TEMPLATE;
+    writeFileSync4(readmePath, readmeContent, "utf-8");
+    const configPath = join8(notePath, ".tnotes.json");
+    const now = Date.now();
+    const config2 = {
+      id: configId || uuidv4(),
+      // 配置 ID 使用 UUID（跨知识库唯一）
+      bilibili: [],
+      tnotes: [],
+      yuque: [],
+      done: false,
+      category,
+      enableDiscussions,
+      created_at: now,
+      updated_at: now
+    };
+    this.noteManager.writeNoteConfig(configPath, config2);
+    logger.info(`Created new note: ${dirName}`);
+    return {
+      index: noteIndex,
+      // 返回的 id 是笔记索引（目录前缀）
+      path: notePath,
+      dirName,
+      readmePath,
+      configPath,
+      config: config2
+    };
+  }
+  /**
+   * 生成下一个笔记索引（填充空缺）
+   * @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 = readFileSync5(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);
+        writeFileSync4(noteInfo.readmePath, lines.join("\n"), "utf-8");
+        logger.info(`Added title to: ${noteInfo.dirName}`);
+        return true;
+      }
+      if (firstLine !== expectedH1) {
+        lines[0] = expectedH1;
+        writeFileSync4(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;
+    if (!this.notesDir) {
+      throw new Error(NOTES_DIR_NOT_SET_ERROR);
+    }
+    this.init();
+  }
+  watchState;
+  scheduler;
+  renameDetector;
+  configHandler;
+  readmeHandler;
+  coordinator;
+  folderHandler;
+  adapter;
+  noteService;
+  readmeService;
+  noteIndexCache;
+  unlockTimer = null;
+  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 - 私有实现
+};
+
+// services/git/service.ts
+var GitService = class {
+  gitManager;
+  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 existsSync8 } from "fs";
+import { join as join9, basename as basename2 } from "path";
+var SyncCoreService = class {
+  /**
+   * 同步单个仓库的 submodule 到最新版本
+   */
+  async syncSingleRepo(targetDir) {
+    const repoName2 = basename2(targetDir);
+    const submodulePath = join9(targetDir, ".vitepress", "tnotes");
+    try {
+      if (!existsSync8(join9(targetDir, ".gitmodules"))) {
+        return {
+          dir: targetDir,
+          repoName: repoName2,
+          success: false,
+          updated: false,
+          error: "\u672A\u627E\u5230 .gitmodules\uFF0C\u8BE5\u4ED3\u5E93\u672A\u914D\u7F6E submodule"
+        };
+      }
+      if (!existsSync8(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 tnotesjs/core"',
+          targetDir
+        );
+      }
+      return {
+        dir: targetDir,
+        repoName: repoName2,
+        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: repoName2,
+        success: false,
+        updated: false,
+        error: errorMessage
+      };
+    }
+  }
+  /**
+   * 同步所有兄弟仓库的 tnotesjs/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 tnotesjs/core...`);
+      console.log();
+      const results = [];
+      for (let i = 0; i < targetDirs.length; i++) {
+        const dir = targetDirs[i];
+        const repoName2 = basename2(dir);
+        logger.info(`[${i + 1}/${targetDirs.length}] ${repoName2}`);
+        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(`tnotesjs/core \u540C\u6B65\u5931\u8D25: ${errorMessage}`);
+      throw error;
+    }
+  }
+};
+
+// services/timestamp/service.ts
+import {
+  existsSync as existsSync9,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync5,
+  readdirSync as readdirSync4,
+  statSync as statSync2
+} from "fs";
+import { join as join10 } from "path";
+import { execSync as execSync3 } from "child_process";
+var BIRTH_DATE = (/* @__PURE__ */ new Date("1999-06-29T00:00:00+08:00")).getTime();
+var TimestampService = class {
+  noteManager;
+  constructor() {
+    this.noteManager = NoteManager.getInstance();
+  }
+  /**
+   * 从 git 获取文件的创建时间和最后修改时间
+   * @param noteDirPath - 笔记目录路径
+   * @returns 时间戳对象，包含 created_at 和 updated_at
+   */
+  getGitTimestamps(noteDirPath) {
+    try {
+      const readmePath = join10(noteDirPath, "README.md");
+      const createdAtOutput = execSync3(
+        `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 = execSync3(
+        `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 = join10(NOTES_DIR_PATH, noteDir, ".tnotes.json");
+    if (!existsSync9(configPath)) {
+      return false;
+    }
+    try {
+      const configContent = readFileSync6(configPath, "utf-8");
+      const config2 = JSON.parse(configContent);
+      const noteDirPath = join10(NOTES_DIR_PATH, noteDir);
+      const timestamps = this.getGitTimestamps(noteDirPath);
+      if (!timestamps) {
+        return false;
+      }
+      let modified = false;
+      if (forceUpdate || !config2.created_at || config2.created_at !== timestamps.created_at) {
+        config2.created_at = timestamps.created_at;
+        modified = true;
+      }
+      if (forceUpdate) {
+        if (config2.updated_at !== timestamps.updated_at) {
+          config2.updated_at = timestamps.updated_at;
+          modified = true;
+        }
+      } else {
+        if (!config2.updated_at) {
+          config2.updated_at = timestamps.updated_at;
+          modified = true;
+        } else if (timestamps.updated_at > config2.updated_at) {
+          config2.updated_at = timestamps.updated_at;
+          modified = true;
+        }
+      }
+      if (modified) {
+        this.noteManager.writeNoteConfig(configPath, config2);
+        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 = readFileSync6(ROOT_CONFIG_PATH, "utf-8");
+      const config2 = JSON.parse(configContent);
+      const createdAtOutput = execSync3("git log --reverse --format=%ct", {
+        cwd: ROOT_DIR_PATH,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"]
+      }).trim();
+      const updatedAtOutput = execSync3("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 || !config2.root_item.created_at || config2.root_item.created_at !== createdAt) {
+        config2.root_item.created_at = createdAt;
+        modified = true;
+      }
+      if (forceUpdate || !config2.root_item.updated_at || config2.root_item.updated_at !== updatedAt) {
+        config2.root_item.updated_at = updatedAt;
+        modified = true;
+      }
+      if (modified) {
+        const daysSinceBirth = Math.floor((updatedAt - BIRTH_DATE) / (1e3 * 60 * 60 * 24)) + 1;
+        config2.root_item.days_since_birth = daysSinceBirth;
+        writeFileSync5(
+          ROOT_CONFIG_PATH,
+          JSON.stringify(config2, 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 (!existsSync9(NOTES_DIR_PATH)) {
+      logger.error("notes \u76EE\u5F55\u4E0D\u5B58\u5728");
+      return { fixed: 0, skipped: 0, total: 0, rootConfigFixed };
+    }
+    const noteDirs = readdirSync4(NOTES_DIR_PATH).filter((name) => {
+      const fullPath = join10(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 = join10(NOTES_DIR_PATH, noteDir, ".tnotes.json");
+      if (!existsSync9(configPath)) {
+        continue;
+      }
+      try {
+        const configContent = readFileSync6(configPath, "utf-8");
+        const config2 = JSON.parse(configContent);
+        config2.updated_at = now;
+        this.noteManager.writeNoteConfig(configPath, config2);
+        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 {
+  /** VitePress 开发服务器默认端口 */
+  static DEFAULT_DEV_PORT = 5173;
+  /** VitePress 预览服务器默认端口 */
+  static DEFAULT_PREVIEW_PORT = 4173;
+  /** 开发服务器进程 ID 后缀 */
+  static PROCESS_ID_DEV_SUFFIX = "vitepress-dev";
+  /** 预览服务器进程 ID 后缀 */
+  static PROCESS_ID_PREVIEW_SUFFIX = "vitepress-preview";
+  /** 服务启动超时时间（毫秒） */
+  static SERVER_STARTUP_TIMEOUT = 6e4;
+  /** 端口释放等待超时时间（毫秒） */
+  static PORT_RELEASE_TIMEOUT = 3e3;
+  /** 进程清理等待时间（毫秒） */
+  static PROCESS_CLEANUP_DELAY = 3e3;
+  /** 显示启动服务状态行间隔（毫秒） */
+  static SERVER_STATUS_LINE_INTERVAL = 1e3;
+  /** 默认包管理器 */
+  static DEFAULT_PACKAGE_MANAGER = "pnpm";
+  processManager;
+  configManager;
+  constructor() {
+    this.processManager = new ProcessManager();
+    this.configManager = ConfigManager.getInstance();
+  }
+  /**
+   * 启动 VitePress 开发服务器
+   * @returns 启动结果（服务就绪后返回），失败时返回 undefined
+   */
+  async startServer() {
+    const port2 = this.configManager.get("port") || _VitepressService.DEFAULT_DEV_PORT;
+    const repoName2 = this.configManager.get("repoName");
+    const processId = `${repoName2}-${_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(port2)) {
+      logger.warn(`\u7AEF\u53E3 ${port2} \u88AB\u5360\u7528\uFF0C\u6B63\u5728\u6E05\u7406...`);
+      killPortProcess(port2);
+      const available = await waitForPort(
+        port2,
+        _VitepressService.PORT_RELEASE_TIMEOUT
+      );
+      if (available) {
+        logger.info(`\u7AEF\u53E3 ${port2} \u5DF2\u91CA\u653E\uFF0C\u7EE7\u7EED\u542F\u52A8\u670D\u52A1`);
+      } else {
+        logger.warn(
+          `\u7AEF\u53E3 ${port2} \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", port2.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 repoName2 = this.configManager.get("repoName");
+    const processId = `${repoName2}-${_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/note/UpdateNoteConfigCommand.ts
+var UpdateNoteConfigCommand = class extends BaseCommand {
+  noteService;
+  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: config2 } = params;
+    const note = this.noteService.getNoteByIndex(noteIndex);
+    if (!note) {
+      throw new Error(`\u7B14\u8BB0\u672A\u627E\u5230: ${noteIndex}`);
+    }
+    await this.noteService.updateNoteConfig(noteIndex, config2);
+    this.logger.info(`\u2705 \u7B14\u8BB0 ${noteIndex} \u914D\u7F6E\u5DF2\u66F4\u65B0:`);
+    if (config2.done !== void 0)
+      this.logger.info(`  - \u5B8C\u6210\u72B6\u6001: ${config2.done}`);
+    if (config2.enableDiscussions !== void 0)
+      this.logger.info(`  - \u8BC4\u8BBA\u72B6\u6001: ${config2.enableDiscussions}`);
+    if (config2.description !== void 0)
+      this.logger.info(`  - \u7B14\u8BB0\u7B80\u4ECB: ${config2.description || "(\u7A7A)"}`);
+  }
+};
+
+// commands/note/RenameNoteCommand.ts
+import { existsSync as existsSync10, renameSync, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { join as join11 } from "path";
+var RenameNoteCommand = class extends BaseCommand {
+  noteService;
+  readmeService;
+  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 = join11(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 = join11(newPath, "README.md");
+      if (existsSync10(readmePath)) {
+        const content = readFileSync7(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;
+          writeFileSync6(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);
+    }
+  }
+};
+
+export {
+  COMMAND_NAMES,
+  COMMAND_DESCRIPTIONS,
+  COMMAND_OPTIONS,
+  handleError,
+  generateAnchor,
+  getTargetDirs,
+  logger,
+  createLogger,
+  parseArgs,
+  parseReadmeCompletedNotes,
+  TNOTES_BASE_DIR,
+  EN_WORDS_DIR,
+  ROOT_DIR_PATH,
+  ROOT_CONFIG_PATH,
+  NoteManager,
+  runCommand,
+  pushAllRepos,
+  pullAllRepos,
+  syncAllRepos,
+  BaseCommand,
+  NoteIndexCache,
+  ReadmeService,
+  NoteService,
+  FileWatcherService,
+  GitService,
+  SyncCoreService,
+  TimestampService,
+  VitepressService,
+  UpdateNoteConfigCommand,
+  RenameNoteCommand
+};