@tnotesjs/core 0.1.0 → 0.1.1

package/dist/cli/index.js

@@ -1,44 +1,8 @@
 #!/usr/bin/env node
 import {
-  CONSTANTS,
   ConfigManager,
-  EN_WORDS_DIR,
-  EOL,
-  Logger,
-  NOTES_DIR_PATH,
-  NOTES_PATH,
-  NoteManager,
-  REPO_NOTES_URL,
-  ROOT_CONFIG_PATH,
-  ROOT_DIR_PATH,
-  ROOT_README_PATH,
-  TNOTES_BASE_DIR,
-  TNOTES_CORE_DIR,
-  VP_SIDEBAR_PATH,
-  buildNoteLineMarkdown,
-  createAddNumberToTitle,
-  createError,
-  createLogger,
-  ensureDirectory,
-  genHierarchicalSidebar,
-  generateToc,
-  getChangedIds,
-  getTargetDirs,
-  handleError,
-  isPortInUse,
-  killPortProcess,
-  logger,
-  parseArgs,
-  parseNoteLine,
-  parseReadmeCompletedNotes,
-  processEmptyLines,
-  pullAllRepos,
-  pushAllRepos,
-  runCommand,
-  syncAllRepos,
-  validateNoteTitle,
-  waitForPort
-} from "../chunk-K3X5OP3N.js";
+  getConfigManager
+} from "../chunk-NYLJBCWL.js";
 
 // commands/models.ts
 var COMMAND_NAMES = {
@@ -67,7 +31,7 @@ var COMMAND_DESCRIPTIONS = {
   [COMMAND_NAMES.PUSH]: "\u5C06\u77E5\u8BC6\u5E93\u63A8\u9001\u5230 GitHub (\u4F7F\u7528 --all \u63A8\u9001\u6240\u6709\u77E5\u8BC6\u5E93)",
   [COMMAND_NAMES.PULL]: "\u5C06 GitHub \u7684\u77E5\u8BC6\u5E93\u62C9\u4E0B\u6765 (\u4F7F\u7528 --all \u62C9\u53D6\u6240\u6709\u77E5\u8BC6\u5E93)",
   [COMMAND_NAMES.SYNC]: "\u540C\u6B65\u672C\u5730\u548C\u8FDC\u7A0B\u7684\u77E5\u8BC6\u5E93\u72B6\u6001 (\u4F7F\u7528 --all \u540C\u6B65\u6240\u6709\u77E5\u8BC6\u5E93)",
-  [COMMAND_NAMES.SYNC_CORE]: "\u540C\u6B65\u6240\u6709\u5144\u5F1F\u77E5\u8BC6\u5E93\u7684 TNotes.core \u5230\u6700\u65B0\u7248\u672C",
+  [COMMAND_NAMES.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",
@@ -79,13 +43,1302 @@ var COMMAND_OPTIONS = {
   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/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/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/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/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/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((resolve4) => setTimeout(resolve4, 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((resolve4, reject) => {
+    exec(command, { cwd: dir }, (error, stdout, stderr) => {
+      if (error) {
+        console.error(`\u5904\u7406 ${dir} \u65F6\u51FA\u9519\uFF1A${stderr}`);
+        reject(error);
+      } else {
+        resolve4(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 };
+}
+
 // commands/BaseCommand.ts
 var BaseCommand = class {
   constructor(name) {
     this.name = name;
-    this.options = {};
     this.logger = logger.child(name);
   }
+  logger;
+  options = {};
   /** 命令描述（从静态配置读取） */
   get description() {
     return COMMAND_DESCRIPTIONS[this.name];
@@ -129,19 +1382,19 @@ async function safeExecute(label, fn, logger2) {
 }
 
 // services/file-watcher/watchState.ts
-import { existsSync, readFileSync, readdirSync, statSync } from "fs";
+import { existsSync as existsSync2, readFileSync as readFileSync2, readdirSync as readdirSync3, statSync } from "fs";
 import { createHash } from "crypto";
-import { join } from "path";
+import { join as join3 } from "path";
 var WatchState = class {
-  constructor(config) {
-    this.config = config;
-    /** 文件哈希缓存 */
-    this.fileHashes = /* @__PURE__ */ new Map();
-    /** 笔记目录缓存 */
-    this.noteDirCache = /* @__PURE__ */ new Set();
-    /** 笔记配置缓存 */
-    this.configCache = /* @__PURE__ */ new Map();
-  }
+  constructor(config2) {
+    this.config = config2;
+  }
+  /** 文件哈希缓存 */
+  fileHashes = /* @__PURE__ */ new Map();
+  /** 笔记目录缓存 */
+  noteDirCache = /* @__PURE__ */ new Set();
+  /** 笔记配置缓存 */
+  configCache = /* @__PURE__ */ new Map();
   /**
    * 获取指定文件的 MD5 哈希值，若文件不存在或读取失败返回 null
    *
@@ -150,8 +1403,8 @@ var WatchState = class {
    */
   getFileHash(filePath) {
     try {
-      if (!existsSync(filePath)) return null;
-      const content = readFileSync(filePath, "utf-8");
+      if (!existsSync2(filePath)) return null;
+      const content = readFileSync2(filePath, "utf-8");
       if (content.length === 0) return null;
       return createHash("md5").update(content).digest("hex");
     } catch {
@@ -211,8 +1464,8 @@ var WatchState = class {
    * @param noteDirName 笔记目录名称
    */
   clearNoteCaches(noteDirName) {
-    const readmePath = join(this.config.notesDir, noteDirName, "README.md");
-    const configPath = join(this.config.notesDir, noteDirName, ".tnotes.json");
+    const readmePath = join3(this.config.notesDir, noteDirName, "README.md");
+    const configPath = join3(this.config.notesDir, noteDirName, ".tnotes.json");
     this.fileHashes.delete(readmePath);
     this.fileHashes.delete(configPath);
     this.configCache.delete(configPath);
@@ -245,13 +1498,13 @@ var WatchState = class {
    */
   readConfigSnapshot(configPath) {
     try {
-      if (!existsSync(configPath)) return null;
-      const content = readFileSync(configPath, "utf-8");
-      const config = JSON.parse(content);
+      if (!existsSync2(configPath)) return null;
+      const content = readFileSync2(configPath, "utf-8");
+      const config2 = JSON.parse(content);
       return {
-        done: Boolean(config.done),
-        enableDiscussions: Boolean(config.enableDiscussions),
-        description: config.description || ""
+        done: Boolean(config2.done),
+        enableDiscussions: Boolean(config2.enableDiscussions),
+        description: config2.description || ""
       };
     } catch (error) {
       this.config.logger.error(`[\u8BFB\u53D6\u914D\u7F6E\u5FEB\u7167] ${error}`);
@@ -265,16 +1518,16 @@ var WatchState = class {
    */
   initializeFromDisk() {
     try {
-      const noteDirs = readdirSync(this.config.notesDir);
+      const noteDirs = readdirSync3(this.config.notesDir);
       this.clearAll();
       for (const noteDir of noteDirs) {
-        const noteDirPath = join(this.config.notesDir, noteDir);
+        const noteDirPath = join3(this.config.notesDir, noteDir);
         if (!statSync(noteDirPath).isDirectory()) continue;
         this.noteDirCache.add(noteDir);
-        const readmePath = join(noteDirPath, "README.md");
+        const readmePath = join3(noteDirPath, "README.md");
         const readmeHash = this.getFileHash(readmePath);
         if (readmeHash) this.fileHashes.set(readmePath, readmeHash);
-        const configPath = join(noteDirPath, ".tnotes.json");
+        const configPath = join3(noteDirPath, ".tnotes.json");
         const configHash = this.getFileHash(configPath);
         if (configHash) {
           this.fileHashes.set(configPath, configHash);
@@ -296,23 +1549,27 @@ var DEFAULT_BATCH_WINDOW_MS = 1e3;
 var DEFAULT_BATCH_THRESHOLD = 3;
 var DEFAULT_BATCH_BUFFER_MS = 2e3;
 var EventScheduler = class {
-  constructor(config) {
-    this.config = config;
-    /** 待处理的文件变更事件队列 */
-    this.pendingEvents = /* @__PURE__ */ new Map();
-    /** 防抖定时器 */
-    this.updateTimer = null;
-    /** 批量更新恢复定时器 */
-    this.batchResumeTimer = null;
-    /** 记录最近的变更时间戳 */
-    this.recentChanges = [];
-    /** 标记是否正在更新，避免循环触发 - 类似一把更新行为锁 */
-    this.isUpdating = false;
-    this.debounceMs = config.debounceMs ?? DEFAULT_DEBOUNCE_MS;
-    this.batchWindowMs = config.batchWindowMs ?? DEFAULT_BATCH_WINDOW_MS;
-    this.batchThreshold = config.batchThreshold ?? DEFAULT_BATCH_THRESHOLD;
-    this.batchBufferMs = config.batchBufferMs ?? DEFAULT_BATCH_BUFFER_MS;
-  }
+  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;
   /**
    * 设置更新状态锁，用于防止在执行耗时更新操作时被新的文件变更事件打断
    *
@@ -409,21 +1666,21 @@ var EventScheduler = class {
 };
 
 // services/file-watcher/renameDetector.ts
-import { existsSync as existsSync2 } from "fs";
-import { join as join2 } from "path";
+import { existsSync as existsSync3 } from "fs";
+import { join as join4 } from "path";
 var FOLDER_RENAME_DETECT_WINDOW_MS = 500;
 var RenameDetector = class {
-  constructor(config) {
-    this.config = config;
-    /** 待处理的文件夹重命名 */
-    this.pendingFolderRename = null;
-    /** 文件夹重命名检测定时器 */
-    this.folderRenameTimer = null;
+  constructor(config2) {
+    this.config = config2;
   }
+  /** 待处理的文件夹重命名 */
+  pendingFolderRename = null;
+  /** 文件夹重命名检测定时器 */
+  folderRenameTimer = null;
   handleFsRename(folderName) {
     const { notesDir, dirCache, logger: logger2, onDelete, onRename } = this.config;
-    const folderPath = join2(notesDir, folderName);
-    const folderExists = existsSync2(folderPath);
+    const folderPath = join4(notesDir, folderName);
+    const folderExists = existsSync3(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}`);
@@ -479,8 +1736,8 @@ var RenameDetector = class {
 
 // services/file-watcher/configChangeHandler.ts
 var ConfigChangeHandler = class {
-  constructor(config) {
-    this.config = config;
+  constructor(config2) {
+    this.config = config2;
   }
   async handle(events) {
     if (events.length === 0) return [];
@@ -512,8 +1769,8 @@ var ConfigChangeHandler = class {
 
 // services/file-watcher/readmeChangeHandler.ts
 var ReadmeChangeHandler = class {
-  constructor(config) {
-    this.config = config;
+  constructor(config2) {
+    this.config = config2;
   }
   async handle(events) {
     if (events.length === 0) return;
@@ -529,8 +1786,8 @@ var ReadmeChangeHandler = class {
 
 // services/file-watcher/globalUpdateCoordinator.ts
 var GlobalUpdateCoordinator = class {
-  constructor(config) {
-    this.config = config;
+  constructor(config2) {
+    this.config = config2;
   }
   async applyConfigUpdates(changedNoteIndexes) {
     if (changedNoteIndexes.length === 0) return;
@@ -560,17 +1817,17 @@ var GlobalUpdateCoordinator = class {
 };
 
 // services/file-watcher/folderChangeHandler.ts
-import { existsSync as existsSync3, promises as fsPromises } from "fs";
-import { join as join3 } from "path";
+import { existsSync as existsSync4, promises as fsPromises } from "fs";
+import { join as join5 } from "path";
 var RENAME_REVERT_DELAY_MS = 2e3;
 var DELETE_REINIT_DELAY_MS = 1e3;
 var UPDATE_UNLOCK_DELAY_MS = 500;
 var FolderChangeHandler = class {
-  constructor(config) {
-    this.config = config;
-    /** 活跃的定时器 ID 集合，用于统一清理 */
-    this.activeTimers = /* @__PURE__ */ new Set();
+  constructor(config2) {
+    this.config = config2;
   }
+  /** 活跃的定时器 ID 集合，用于统一清理 */
+  activeTimers = /* @__PURE__ */ new Set();
   /**
    * 清理所有活跃定时器，释放资源
    *
@@ -695,9 +1952,9 @@ var FolderChangeHandler = class {
   async revertFolderRename(oldName, newName) {
     const { notesDir, scheduler, watchState, logger: logger2 } = this.config;
     try {
-      const oldPath = join3(notesDir, oldName);
-      const newPath = join3(notesDir, newName);
-      if (existsSync3(newPath)) {
+      const oldPath = join5(notesDir, oldName);
+      const newPath = join5(notesDir, newName);
+      if (existsSync4(newPath)) {
         scheduler.setUpdating(true);
         await fsPromises.rename(newPath, oldPath);
         logger2.warn(`\u6587\u4EF6\u5939\u5DF2\u56DE\u9000: ${newName} \u2192 ${oldName}`);
@@ -722,13 +1979,13 @@ var FolderChangeHandler = class {
 
 // services/file-watcher/fsWatcherAdapter.ts
 import { watch } from "fs";
-import { basename, dirname, join as join4, sep } from "path";
+import { basename, dirname, join as join6, sep } from "path";
 var FsWatcherAdapter = class {
-  constructor(config) {
-    this.config = config;
-    /** 文件系统监听器实例 */
-    this.watcher = null;
+  constructor(config2) {
+    this.config = config2;
   }
+  /** 文件系统监听器实例 */
+  watcher = null;
   start() {
     const { logger: logger2 } = this.config;
     if (this.watcher) {
@@ -765,7 +2022,7 @@ var FsWatcherAdapter = class {
     if (baseFilename !== "README.md" && baseFilename !== ".tnotes.json") {
       return;
     }
-    const fullPath = join4(this.config.notesDir, filename);
+    const fullPath = join6(this.config.notesDir, filename);
     const event = this.buildWatchEvent(fullPath, filename);
     if (!event) {
       return;
@@ -791,7 +2048,7 @@ var FsWatcherAdapter = class {
 };
 
 // core/ReadmeGenerator.ts
-import { readFileSync as readFileSync2, writeFileSync, existsSync as existsSync4 } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync5 } from "fs";
 
 // core/TocGenerator.ts
 var BILIBILI_VIDEO_BASE_URL = "https://www.bilibili.com/video/";
@@ -806,7 +2063,7 @@ var TocGenerator = class {
    * @param noteConfig - 笔记配置
    * @param repoName - 仓库名称
    */
-  updateNoteToc(noteIndex, lines, noteConfig, repoName) {
+  updateNoteToc(noteIndex, lines, noteConfig, repoName2) {
     let startLineIdx = -1, endLineIdx = -1;
     lines.forEach((line, idx) => {
       if (line.startsWith(NOTES_TOC_START_TAG)) startLineIdx = idx;
@@ -866,7 +2123,7 @@ var TocGenerator = class {
       if (noteConfig.bilibili.length > 0) {
         noteConfig.bilibili.forEach((bvid, i) => {
           bilibiliTOCItems.push(
-            `  - [bilibili.${repoName}.${noteIndex}.${i + 1}](${BILIBILI_VIDEO_BASE_URL + bvid})`
+            `  - [bilibili.${repoName2}.${noteIndex}.${i + 1}](${BILIBILI_VIDEO_BASE_URL + bvid})`
           );
         });
       }
@@ -874,16 +2131,16 @@ var TocGenerator = class {
         tnotesTOCItems.push(
           `- [\u{1F4D2} TNotes\uFF08\u76F8\u5173\u77E5\u8BC6\u5E93\uFF09](https://tnotesjs.github.io/TNotes/)`
         );
-        noteConfig.tnotes.forEach((repoName2) => {
+        noteConfig.tnotes.forEach((repoName3) => {
           tnotesTOCItems.push(
-            `  - [TNotes.${repoName2}](https://tnotesjs.github.io/TNotes.${repoName2}/)`
+            `  - [TNotes.${repoName3}](https://tnotesjs.github.io/TNotes.${repoName3}/)`
           );
         });
       }
       if (noteConfig.yuque.length > 0) {
         noteConfig.yuque.forEach((slug, i) => {
           yuqueTOCItems.push(
-            `  - [TNotes.yuque.${repoName.replace(
+            `  - [TNotes.yuque.${repoName2.replace(
               "TNotes.",
               ""
             )}.${noteIndex}](${TNOTES_YUQUE_BASE_URL + slug})`
@@ -944,6 +2201,8 @@ var TocGenerator = class {
 
 // core/ReadmeGenerator.ts
 var ReadmeGenerator = class {
+  tocGenerator;
+  configManager;
   constructor() {
     this.tocGenerator = new TocGenerator();
     this.configManager = ConfigManager.getInstance();
@@ -957,18 +2216,18 @@ var ReadmeGenerator = class {
       logger.warn(`\u7B14\u8BB0 ${noteInfo.dirName} \u7F3A\u5C11\u914D\u7F6E\u6587\u4EF6`);
       return;
     }
-    const content = readFileSync2(noteInfo.readmePath, "utf-8");
+    const content = readFileSync3(noteInfo.readmePath, "utf-8");
     if (content.length === 0) return;
     const lines = content.split(EOL);
-    const repoName = this.configManager.get("repoName");
+    const repoName2 = this.configManager.get("repoName");
     this.tocGenerator.updateNoteToc(
       noteInfo.index,
       lines,
       noteInfo.config,
-      repoName
+      repoName2
     );
     const updatedContent = lines.join(EOL);
-    writeFileSync(noteInfo.readmePath, updatedContent, "utf-8");
+    writeFileSync2(noteInfo.readmePath, updatedContent, "utf-8");
   }
   /**
    * 更新首页 README
@@ -977,18 +2236,18 @@ var ReadmeGenerator = class {
    * @param homeReadmePath - 首页 README 路径
    */
   updateHomeReadme(notes, homeReadmePath) {
-    if (!existsSync4(homeReadmePath)) {
+    if (!existsSync5(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 content = readFileSync3(homeReadmePath, "utf-8");
     const lines = content.split(EOL);
     const noteByIndexMap = /* @__PURE__ */ new Map();
     for (const note of notes) {
       noteByIndexMap.set(note.index, note);
     }
     const repoOwner = this.configManager.get("author");
-    const repoName = this.configManager.get("repoName");
+    const repoName2 = this.configManager.get("repoName");
     const existingNoteIndexes = /* @__PURE__ */ new Set();
     const linesToRemove = /* @__PURE__ */ new Set();
     const titles = [];
@@ -1019,7 +2278,7 @@ var ReadmeGenerator = class {
           continue;
         }
         existingNoteIndexes.add(parsed.noteIndex);
-        lines[i] = buildNoteLineMarkdown(note, repoOwner, repoName);
+        lines[i] = buildNoteLineMarkdown(note, repoOwner, repoName2);
         currentNoteCount++;
         continue;
       }
@@ -1062,7 +2321,7 @@ var ReadmeGenerator = class {
       logger.info(`\u6DFB\u52A0 ${missingNotes.length} \u7BC7\u7F3A\u5931\u7684\u7B14\u8BB0\u5230 README`);
       missingNotes.sort((a, b) => a.index.localeCompare(b.index));
       for (const note of missingNotes) {
-        const noteLine = buildNoteLineMarkdown(note, repoOwner, repoName);
+        const noteLine = buildNoteLineMarkdown(note, repoOwner, repoName2);
         lines.push(noteLine);
         currentNoteCount++;
       }
@@ -1073,24 +2332,22 @@ var ReadmeGenerator = class {
     this.tocGenerator.updateHomeToc(lines, titles, titlesNotesCount);
     const processedLines = processEmptyLines(lines);
     const updatedContent = processedLines.join(EOL);
-    writeFileSync(homeReadmePath, updatedContent, "utf-8");
+    writeFileSync2(homeReadmePath, updatedContent, "utf-8");
     logger.info("\u5DF2\u66F4\u65B0\u9996\u9875 README");
   }
 };
 
 // core/NoteIndexCache.ts
-import { join as join5 } from "path";
+import { join as join7 } 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() {
-    /** noteIndex -> NoteIndexItem 的映射 */
-    this.byNoteIndex = /* @__PURE__ */ new Map();
-    /** configId (UUID) -> noteIndex 的映射，用于快速反向查询 */
-    this.byConfigId = /* @__PURE__ */ new Map();
-    /** 是否已完成初始化 */
-    this._initialized = false;
-  }
-  static {
-    this.instance = null;
   }
   /**
    * 获取单例实例
@@ -1132,13 +2389,13 @@ var NoteIndexCache = class _NoteIndexCache {
   toNoteInfoList() {
     const result = [];
     for (const item of this.byNoteIndex.values()) {
-      const notePath = join5(NOTES_PATH, item.folderName);
+      const notePath = join7(NOTES_PATH, item.folderName);
       result.push({
         index: item.noteIndex,
         path: notePath,
         dirName: item.folderName,
-        readmePath: join5(notePath, "README.md"),
-        configPath: join5(notePath, ".tnotes.json"),
+        readmePath: join7(notePath, "README.md"),
+        configPath: join7(notePath, ".tnotes.json"),
         config: item.noteConfig
       });
     }
@@ -1224,12 +2481,17 @@ var NoteIndexCache = class _NoteIndexCache {
 
 // services/readme/service.ts
 import {
-  existsSync as existsSync5,
-  readFileSync as readFileSync3,
-  writeFileSync as writeFileSync2,
+  existsSync as existsSync6,
+  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();
@@ -1354,11 +2616,11 @@ var ReadmeService = class _ReadmeService {
    * @param notes - 笔记信息数组
    */
   async updateSidebar(notes) {
-    if (!existsSync5(ROOT_README_PATH)) {
+    if (!existsSync6(ROOT_README_PATH)) {
       logger.error("\u672A\u627E\u5230\u9996\u9875 README\uFF0C\u65E0\u6CD5\u751F\u6210\u4FA7\u8FB9\u680F");
       return;
     }
-    const content = readFileSync3(ROOT_README_PATH, "utf-8");
+    const content = readFileSync4(ROOT_README_PATH, "utf-8");
     const lines = content.split("\n");
     const itemList = [];
     const titles = [];
@@ -1390,9 +2652,9 @@ var ReadmeService = class _ReadmeService {
             statusEmoji = "\u2705 ";
           }
         }
-        const sidebarShowNoteId = this.configManager.get("sidebarShowNoteId");
+        const sidebarShowNoteId2 = this.configManager.get("sidebarShowNoteId");
         let displayText = note.dirName;
-        if (!sidebarShowNoteId) {
+        if (!sidebarShowNoteId2) {
           displayText = note.dirName.replace(/^\d{4}\.\s/, "");
         }
         itemList.push({
@@ -1421,7 +2683,7 @@ var ReadmeService = class _ReadmeService {
       titlesNotesCount,
       sidebarIsCollapsed
     );
-    writeFileSync2(
+    writeFileSync3(
       VP_SIDEBAR_PATH,
       JSON.stringify(hierarchicalSidebar, null, 2),
       "utf-8"
@@ -1449,7 +2711,7 @@ var ReadmeService = class _ReadmeService {
     const content = await fsPromises2.readFile(ROOT_README_PATH, "utf-8");
     const lines = content.split("\n");
     const repoOwner = this.configManager.get("author");
-    const repoName = this.configManager.get("repoName");
+    const repoName2 = this.configManager.get("repoName");
     const mergedConfig = { ...item.noteConfig, ...updates };
     const tempNoteInfo = {
       index: noteIndex,
@@ -1463,7 +2725,7 @@ var ReadmeService = class _ReadmeService {
     for (let i = 0; i < lines.length; i++) {
       const parsed = parseNoteLine(lines[i]);
       if (parsed.noteIndex === noteIndex) {
-        lines[i] = buildNoteLineMarkdown(tempNoteInfo, repoOwner, repoName);
+        lines[i] = buildNoteLineMarkdown(tempNoteInfo, repoOwner, repoName2);
         updated = true;
       }
     }
@@ -1513,7 +2775,7 @@ var ReadmeService = class _ReadmeService {
     const content = await fsPromises2.readFile(ROOT_README_PATH, "utf-8");
     const lines = content.split("\n");
     const repoOwner = this.configManager.get("author");
-    const repoName = this.configManager.get("repoName");
+    const repoName2 = this.configManager.get("repoName");
     const tempNoteInfo = {
       index: noteIndex,
       dirName: item.folderName,
@@ -1522,7 +2784,7 @@ var ReadmeService = class _ReadmeService {
       configPath: "",
       config: item.noteConfig
     };
-    const noteLine = buildNoteLineMarkdown(tempNoteInfo, repoOwner, repoName);
+    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}`);
@@ -1539,8 +2801,8 @@ var ReadmeService = class _ReadmeService {
 };
 
 // services/note/service.ts
-import { writeFileSync as writeFileSync3, readFileSync as readFileSync4 } from "fs";
-import { join as join6 } from "path";
+import { writeFileSync as writeFileSync4, readFileSync as readFileSync5 } from "fs";
+import { join as join8 } from "path";
 import { v4 as uuidv4 } from "uuid";
 
 // config/templates.ts
@@ -1568,8 +2830,11 @@ var NEW_NOTES_README_MD_TEMPLATE = `
 - todo
 `;
 var NoteService = class _NoteService {
+  static instance;
+  noteManager;
+  noteIndexCache;
+  ignoredConfigPaths = /* @__PURE__ */ new Set();
   constructor() {
-    this.ignoredConfigPaths = /* @__PURE__ */ new Set();
     this.noteManager = NoteManager.getInstance();
     this.noteIndexCache = NoteIndexCache.getInstance();
   }
@@ -1632,15 +2897,15 @@ var NoteService = class _NoteService {
     } = options;
     const noteIndex = this.generateNextNoteIndex(usedIndexes);
     const dirName = `${noteIndex}. ${title}`;
-    const notePath = join6(NOTES_PATH, dirName);
+    const notePath = join8(NOTES_PATH, dirName);
     await ensureDirectory(notePath);
-    const readmePath = join6(notePath, "README.md");
+    const readmePath = join8(notePath, "README.md");
     const noteTitle = generateNoteTitle(noteIndex, title, REPO_NOTES_URL);
     const readmeContent = noteTitle + "\n" + NEW_NOTES_README_MD_TEMPLATE;
-    writeFileSync3(readmePath, readmeContent, "utf-8");
-    const configPath = join6(notePath, ".tnotes.json");
+    writeFileSync4(readmePath, readmeContent, "utf-8");
+    const configPath = join8(notePath, ".tnotes.json");
     const now = Date.now();
-    const config = {
+    const config2 = {
       id: configId || uuidv4(),
       // 配置 ID 使用 UUID（跨知识库唯一）
       bilibili: [],
@@ -1652,7 +2917,7 @@ var NoteService = class _NoteService {
       created_at: now,
       updated_at: now
     };
-    this.noteManager.writeNoteConfig(configPath, config);
+    this.noteManager.writeNoteConfig(configPath, config2);
     logger.info(`Created new note: ${dirName}`);
     return {
       index: noteIndex,
@@ -1661,7 +2926,7 @@ var NoteService = class _NoteService {
       dirName,
       readmePath,
       configPath,
-      config
+      config: config2
     };
   }
   /**
@@ -1745,7 +3010,7 @@ var NoteService = class _NoteService {
    */
   async fixNoteTitle(noteInfo) {
     try {
-      const readmeContent = readFileSync4(noteInfo.readmePath, "utf-8");
+      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+(.+)$/);
@@ -1762,13 +3027,13 @@ var NoteService = class _NoteService {
       const firstLine = lines[0].trim();
       if (!firstLine.startsWith("# ")) {
         lines.unshift(expectedH1);
-        writeFileSync3(noteInfo.readmePath, lines.join("\n"), "utf-8");
+        writeFileSync4(noteInfo.readmePath, lines.join("\n"), "utf-8");
         logger.info(`Added title to: ${noteInfo.dirName}`);
         return true;
       }
       if (firstLine !== expectedH1) {
         lines[0] = expectedH1;
-        writeFileSync3(noteInfo.readmePath, lines.join("\n"), "utf-8");
+        writeFileSync4(noteInfo.readmePath, lines.join("\n"), "utf-8");
         logger.info(`Fixed title for: ${noteInfo.dirName}`);
         return true;
       }
@@ -1805,12 +3070,23 @@ var UPDATE_UNLOCK_DELAY_MS2 = 500;
 var FileWatcherService = class {
   constructor(notesDir = NOTES_DIR_PATH) {
     this.notesDir = notesDir;
-    this.unlockTimer = null;
     if (!this.notesDir) {
       throw new Error(NOTES_DIR_NOT_SET_ERROR);
     }
     this.init();
   }
+  watchState;
+  scheduler;
+  renameDetector;
+  configHandler;
+  readmeHandler;
+  coordinator;
+  folderHandler;
+  adapter;
+  noteService;
+  readmeService;
+  noteIndexCache;
+  unlockTimer = null;
   init() {
     this.noteService = NoteService.getInstance();
     this.readmeService = ReadmeService.getInstance();
@@ -1962,9 +3238,11 @@ var FileWatcherService = class {
 };
 
 // core/GitManager.ts
-import { resolve } from "path";
-import { existsSync as existsSync6 } from "fs";
+import { resolve as resolve2 } from "path";
+import { existsSync as existsSync7 } from "fs";
 var GitManager = class {
+  logger;
+  dir;
   constructor(dir, logger2) {
     this.dir = dir;
     this.logger = logger2?.child("git") || new Logger({ prefix: "git" });
@@ -2003,8 +3281,8 @@ var GitManager = class {
     const lines = statusOutput.trim().split("\n").filter((line) => line);
     const files = lines.map((line) => {
       const statusCode = line.substring(0, 2);
-      let path = line.substring(3);
-      path = path.replace(/^"(.*)"$/, "$1");
+      let path2 = line.substring(3);
+      path2 = path2.replace(/^"(.*)"$/, "$1");
       let status = "modified";
       if (line.startsWith("??")) {
         status = "untracked";
@@ -2013,7 +3291,7 @@ var GitManager = class {
       } else if (/^.[MD]/.test(statusCode)) {
         status = "unstaged";
       }
-      return { path, status, statusCode };
+      return { path: path2, status, statusCode };
     });
     const staged = files.filter((f) => f.status === "staged").length;
     const unstaged = files.filter((f) => f.status === "unstaged").length;
@@ -2278,7 +3556,7 @@ var GitManager = class {
    * 检查仓库是否包含 submodule
    */
   hasSubmodules() {
-    return existsSync6(resolve(this.dir, ".gitmodules"));
+    return existsSync7(resolve2(this.dir, ".gitmodules"));
   }
   /**
    * 获取所有 submodule 的路径
@@ -2302,7 +3580,7 @@ var GitManager = class {
     const paths = await this.getSubmodulePaths();
     if (paths.length === 0) return;
     for (const subPath of paths) {
-      const absPath = resolve(this.dir, subPath);
+      const absPath = resolve2(this.dir, subPath);
       let hasChanges = false;
       try {
         const status = await runCommand("git status --porcelain", absPath);
@@ -2406,8 +3684,9 @@ var GitManager = class {
 // core/ProcessManager.ts
 import { spawn } from "child_process";
 var ProcessManager = class {
+  processes = /* @__PURE__ */ new Map();
+  logger;
   constructor() {
-    this.processes = /* @__PURE__ */ new Map();
     this.logger = new Logger({ prefix: "process" });
     process.on("exit", () => {
       this.killAll();
@@ -2528,6 +3807,7 @@ var ProcessManager = class {
 
 // services/git/service.ts
 var GitService = class {
+  gitManager;
   constructor() {
     this.gitManager = new GitManager(ROOT_DIR_PATH);
   }
@@ -2603,26 +3883,26 @@ var GitService = class {
 };
 
 // services/sync-core/service.ts
-import { existsSync as existsSync7 } from "fs";
-import { join as join7, basename as basename2 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { join as join9, basename as basename2 } from "path";
 var SyncCoreService = class {
   /**
    * 同步单个仓库的 submodule 到最新版本
    */
   async syncSingleRepo(targetDir) {
-    const repoName = basename2(targetDir);
-    const submodulePath = join7(targetDir, ".vitepress", "tnotes");
+    const repoName2 = basename2(targetDir);
+    const submodulePath = join9(targetDir, ".vitepress", "tnotes");
     try {
-      if (!existsSync7(join7(targetDir, ".gitmodules"))) {
+      if (!existsSync8(join9(targetDir, ".gitmodules"))) {
         return {
           dir: targetDir,
-          repoName,
+          repoName: repoName2,
           success: false,
           updated: false,
           error: "\u672A\u627E\u5230 .gitmodules\uFF0C\u8BE5\u4ED3\u5E93\u672A\u914D\u7F6E submodule"
         };
       }
-      if (!existsSync7(submodulePath)) {
+      if (!existsSync8(submodulePath)) {
         await runCommand("git submodule update --init", targetDir);
       }
       const beforeHash = (await runCommand("git rev-parse HEAD", submodulePath)).trim();
@@ -2634,11 +3914,14 @@ var SyncCoreService = class {
       const updated = beforeHash !== afterHash;
       if (updated) {
         await runCommand("git add .vitepress/tnotes", targetDir);
-        await runCommand('git commit -m "chore: update TNotes.core"', targetDir);
+        await runCommand(
+          'git commit -m "chore: update tnotesjs/core"',
+          targetDir
+        );
       }
       return {
         dir: targetDir,
-        repoName,
+        repoName: repoName2,
         success: true,
         updated,
         beforeHash: beforeHash.substring(0, 7),
@@ -2650,7 +3933,7 @@ var SyncCoreService = class {
       const errorMessage = error instanceof Error ? error.message : String(error);
       return {
         dir: targetDir,
-        repoName,
+        repoName: repoName2,
         success: false,
         updated: false,
         error: errorMessage
@@ -2658,7 +3941,7 @@ var SyncCoreService = class {
     }
   }
   /**
-   * 同步所有兄弟仓库的 TNotes.core 到最新版本
+   * 同步所有兄弟仓库的 tnotesjs/core 到最新版本
    */
   async syncToAllRepos() {
     try {
@@ -2671,13 +3954,13 @@ var SyncCoreService = class {
         logger.warn("\u672A\u627E\u5230\u7B26\u5408\u6761\u4EF6\u7684\u76EE\u6807\u76EE\u5F55");
         return;
       }
-      logger.info(`\u6B63\u5728\u540C\u6B65 ${targetDirs.length} \u4E2A\u4ED3\u5E93\u7684 TNotes.core...`);
+      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 repoName = basename2(dir);
-        logger.info(`[${i + 1}/${targetDirs.length}] ${repoName}`);
+        const repoName2 = basename2(dir);
+        logger.info(`[${i + 1}/${targetDirs.length}] ${repoName2}`);
         const result = await this.syncSingleRepo(dir);
         results.push(result);
         if (result.success) {
@@ -2717,7 +4000,7 @@ var SyncCoreService = class {
       }
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : String(error);
-      logger.error(`TNotes.core \u540C\u6B65\u5931\u8D25: ${errorMessage}`);
+      logger.error(`tnotesjs/core \u540C\u6B65\u5931\u8D25: ${errorMessage}`);
       throw error;
     }
   }
@@ -2725,16 +4008,17 @@ var SyncCoreService = class {
 
 // services/timestamp/service.ts
 import {
-  existsSync as existsSync8,
-  readFileSync as readFileSync5,
-  writeFileSync as writeFileSync4,
-  readdirSync as readdirSync2,
+  existsSync as existsSync9,
+  readFileSync as readFileSync6,
+  writeFileSync as writeFileSync5,
+  readdirSync as readdirSync4,
   statSync as statSync2
 } from "fs";
-import { join as join8 } from "path";
-import { execSync } from "child_process";
+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();
   }
@@ -2745,8 +4029,8 @@ var TimestampService = class {
    */
   getGitTimestamps(noteDirPath) {
     try {
-      const readmePath = join8(noteDirPath, "README.md");
-      const createdAtOutput = execSync(
+      const readmePath = join10(noteDirPath, "README.md");
+      const createdAtOutput = execSync3(
         `git log --diff-filter=A --follow --format=%ct -- "${readmePath}"`,
         {
           cwd: ROOT_DIR_PATH,
@@ -2754,7 +4038,7 @@ var TimestampService = class {
           stdio: ["pipe", "pipe", "ignore"]
         }
       ).split(/\r?\n/).filter(Boolean).pop();
-      const updatedAtOutput = execSync(
+      const updatedAtOutput = execSync3(
         `git log -1 --format=%ct -- "${readmePath}"`,
         {
           cwd: ROOT_DIR_PATH,
@@ -2782,39 +4066,39 @@ var TimestampService = class {
    * @returns 是否进行了修复
    */
   fixNoteTimestamps(noteDir, forceUpdate = false) {
-    const configPath = join8(NOTES_DIR_PATH, noteDir, ".tnotes.json");
-    if (!existsSync8(configPath)) {
+    const configPath = join10(NOTES_DIR_PATH, noteDir, ".tnotes.json");
+    if (!existsSync9(configPath)) {
       return false;
     }
     try {
-      const configContent = readFileSync5(configPath, "utf-8");
-      const config = JSON.parse(configContent);
-      const noteDirPath = join8(NOTES_DIR_PATH, noteDir);
+      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 || !config.created_at || config.created_at !== timestamps.created_at) {
-        config.created_at = timestamps.created_at;
+      if (forceUpdate || !config2.created_at || config2.created_at !== timestamps.created_at) {
+        config2.created_at = timestamps.created_at;
         modified = true;
       }
       if (forceUpdate) {
-        if (config.updated_at !== timestamps.updated_at) {
-          config.updated_at = timestamps.updated_at;
+        if (config2.updated_at !== timestamps.updated_at) {
+          config2.updated_at = timestamps.updated_at;
           modified = true;
         }
       } else {
-        if (!config.updated_at) {
-          config.updated_at = timestamps.updated_at;
+        if (!config2.updated_at) {
+          config2.updated_at = timestamps.updated_at;
           modified = true;
-        } else if (timestamps.updated_at > config.updated_at) {
-          config.updated_at = timestamps.updated_at;
+        } else if (timestamps.updated_at > config2.updated_at) {
+          config2.updated_at = timestamps.updated_at;
           modified = true;
         }
       }
       if (modified) {
-        this.noteManager.writeNoteConfig(configPath, config);
+        this.noteManager.writeNoteConfig(configPath, config2);
         return true;
       }
       return false;
@@ -2830,14 +4114,14 @@ var TimestampService = class {
    */
   fixRootConfigTimestamps(forceUpdate = false) {
     try {
-      const configContent = readFileSync5(ROOT_CONFIG_PATH, "utf-8");
-      const config = JSON.parse(configContent);
-      const createdAtOutput = execSync("git log --reverse --format=%ct", {
+      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 = execSync("git log -1 --format=%ct", {
+      const updatedAtOutput = execSync3("git log -1 --format=%ct", {
         cwd: ROOT_DIR_PATH,
         encoding: "utf-8",
         stdio: ["pipe", "pipe", "ignore"]
@@ -2849,20 +4133,20 @@ var TimestampService = class {
       const createdAt = parseInt(firstTimestamp) * 1e3;
       const updatedAt = parseInt(updatedAtOutput) * 1e3;
       let modified = false;
-      if (forceUpdate || !config.root_item.created_at || config.root_item.created_at !== createdAt) {
-        config.root_item.created_at = createdAt;
+      if (forceUpdate || !config2.root_item.created_at || config2.root_item.created_at !== createdAt) {
+        config2.root_item.created_at = createdAt;
         modified = true;
       }
-      if (forceUpdate || !config.root_item.updated_at || config.root_item.updated_at !== updatedAt) {
-        config.root_item.updated_at = updatedAt;
+      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;
-        config.root_item.days_since_birth = daysSinceBirth;
-        writeFileSync4(
+        config2.root_item.days_since_birth = daysSinceBirth;
+        writeFileSync5(
           ROOT_CONFIG_PATH,
-          JSON.stringify(config, null, 2) + "\n",
+          JSON.stringify(config2, null, 2) + "\n",
           "utf-8"
         );
         return true;
@@ -2888,12 +4172,12 @@ var TimestampService = class {
     if (rootConfigFixed) {
       logger.success("\u2705 \u6839\u914D\u7F6E\u6587\u4EF6\u65F6\u95F4\u6233\u5DF2\u4FEE\u590D");
     }
-    if (!existsSync8(NOTES_DIR_PATH)) {
+    if (!existsSync9(NOTES_DIR_PATH)) {
       logger.error("notes \u76EE\u5F55\u4E0D\u5B58\u5728");
       return { fixed: 0, skipped: 0, total: 0, rootConfigFixed };
     }
-    const noteDirs = readdirSync2(NOTES_DIR_PATH).filter((name) => {
-      const fullPath = join8(NOTES_DIR_PATH, name);
+    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;
@@ -2930,15 +4214,15 @@ var TimestampService = class {
     const now = Date.now();
     let updatedCount = 0;
     for (const noteDir of noteDirNames) {
-      const configPath = join8(NOTES_DIR_PATH, noteDir, ".tnotes.json");
-      if (!existsSync8(configPath)) {
+      const configPath = join10(NOTES_DIR_PATH, noteDir, ".tnotes.json");
+      if (!existsSync9(configPath)) {
         continue;
       }
       try {
-        const configContent = readFileSync5(configPath, "utf-8");
-        const config = JSON.parse(configContent);
-        config.updated_at = now;
-        this.noteManager.writeNoteConfig(configPath, config);
+        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);
@@ -2967,42 +4251,26 @@ var TimestampService = class {
 // services/vitepress/service.ts
 import { spawn as spawn2 } from "child_process";
 var VitepressService = class _VitepressService {
-  static {
-    /** VitePress 开发服务器默认端口 */
-    this.DEFAULT_DEV_PORT = 5173;
-  }
-  static {
-    /** VitePress 预览服务器默认端口 */
-    this.DEFAULT_PREVIEW_PORT = 4173;
-  }
-  static {
-    /** 开发服务器进程 ID 后缀 */
-    this.PROCESS_ID_DEV_SUFFIX = "vitepress-dev";
-  }
-  static {
-    /** 预览服务器进程 ID 后缀 */
-    this.PROCESS_ID_PREVIEW_SUFFIX = "vitepress-preview";
-  }
-  static {
-    /** 服务启动超时时间（毫秒） */
-    this.SERVER_STARTUP_TIMEOUT = 6e4;
-  }
-  static {
-    /** 端口释放等待超时时间（毫秒） */
-    this.PORT_RELEASE_TIMEOUT = 3e3;
-  }
-  static {
-    /** 进程清理等待时间（毫秒） */
-    this.PROCESS_CLEANUP_DELAY = 3e3;
-  }
-  static {
-    /** 显示启动服务状态行间隔（毫秒） */
-    this.SERVER_STATUS_LINE_INTERVAL = 1e3;
-  }
-  static {
-    /** 默认包管理器 */
-    this.DEFAULT_PACKAGE_MANAGER = "pnpm";
-  }
+  /** 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();
@@ -3012,32 +4280,32 @@ var VitepressService = class _VitepressService {
    * @returns 启动结果（服务就绪后返回），失败时返回 undefined
    */
   async startServer() {
-    const port = this.configManager.get("port") || _VitepressService.DEFAULT_DEV_PORT;
-    const repoName = this.configManager.get("repoName");
-    const processId = `${repoName}-${_VitepressService.PROCESS_ID_DEV_SUFFIX}`;
+    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)
+        (resolve4) => setTimeout(resolve4, _VitepressService.PROCESS_CLEANUP_DELAY)
       );
     }
-    if (isPortInUse(port)) {
-      logger.warn(`\u7AEF\u53E3 ${port} \u88AB\u5360\u7528\uFF0C\u6B63\u5728\u6E05\u7406...`);
-      killPortProcess(port);
+    if (isPortInUse(port2)) {
+      logger.warn(`\u7AEF\u53E3 ${port2} \u88AB\u5360\u7528\uFF0C\u6B63\u5728\u6E05\u7406...`);
+      killPortProcess(port2);
       const available = await waitForPort(
-        port,
+        port2,
         _VitepressService.PORT_RELEASE_TIMEOUT
       );
       if (available) {
-        logger.info(`\u7AEF\u53E3 ${port} \u5DF2\u91CA\u653E\uFF0C\u7EE7\u7EED\u542F\u52A8\u670D\u52A1`);
+        logger.info(`\u7AEF\u53E3 ${port2} \u5DF2\u91CA\u653E\uFF0C\u7EE7\u7EED\u542F\u52A8\u670D\u52A1`);
       } else {
         logger.warn(
-          `\u7AEF\u53E3 ${port} \u672A\u786E\u8BA4\u91CA\u653E\uFF0C\u4ECD\u5C06\u5C1D\u8BD5\u542F\u52A8\uFF1B\u5982\u542F\u52A8\u5931\u8D25\uFF0C\u8BF7\u624B\u52A8\u6E05\u7406\u8BE5\u7AEF\u53E3`
+          `\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", port.toString()];
+    const args = ["vitepress", "dev", "--port", port2.toString()];
     const processInfo = this.processManager.spawn(processId, pm, args, {
       cwd: ROOT_DIR_PATH,
       stdio: ["inherit", "pipe", "pipe"]
@@ -3056,7 +4324,7 @@ var VitepressService = class _VitepressService {
    * @param childProcess - 子进程
    */
   waitForServerReady(childProcess) {
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       const startTime = Date.now();
       let serverReady = false;
       let version = "";
@@ -3083,7 +4351,7 @@ var VitepressService = class _VitepressService {
           process.stderr.clearLine?.(0);
           process.stderr.cursorTo?.(0);
           const elapsed = Date.now() - startTime;
-          setTimeout(() => resolve3({ version, elapsed }), 200);
+          setTimeout(() => resolve4({ version, elapsed }), 200);
           return;
         }
         if (!serverReady) {
@@ -3109,7 +4377,7 @@ var VitepressService = class _VitepressService {
           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 });
+          resolve4({ version, elapsed: _VitepressService.SERVER_STARTUP_TIMEOUT });
         }
       }, _VitepressService.SERVER_STARTUP_TIMEOUT);
     });
@@ -3118,7 +4386,7 @@ var VitepressService = class _VitepressService {
    * 构建生产版本
    */
   build() {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const pm = this.configManager.get("packageManager") || _VitepressService.DEFAULT_PACKAGE_MANAGER;
       const child = spawn2(pm, ["vitepress", "build"], {
         cwd: ROOT_DIR_PATH,
@@ -3142,7 +4410,7 @@ var VitepressService = class _VitepressService {
       });
       child.on("close", (code) => {
         if (code === 0) {
-          resolve3();
+          resolve4();
         } else {
           reject(new Error(`Command failed with code ${code}`));
         }
@@ -3153,8 +4421,8 @@ var VitepressService = class _VitepressService {
    * 预览构建后的站点
    */
   async preview() {
-    const repoName = this.configManager.get("repoName");
-    const processId = `${repoName}-${_VitepressService.PROCESS_ID_PREVIEW_SUFFIX}`;
+    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;
@@ -3187,13 +4455,15 @@ var VitepressService = class _VitepressService {
 };
 
 // commands/update/UpdateCommand.ts
-import { existsSync as existsSync9, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
-import { resolve as resolve2 } from "path";
+import { existsSync as existsSync10, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve3 } from "path";
 var UpdateCommand = class extends BaseCommand {
+  readmeService;
+  noteService;
+  quiet = false;
+  updateAll = false;
   constructor() {
     super("update");
-    this.quiet = false;
-    this.updateAll = false;
     this.readmeService = ReadmeService.getInstance();
     this.noteService = NoteService.getInstance();
   }
@@ -3263,10 +4533,10 @@ var UpdateCommand = class extends BaseCommand {
       let failCount = 0;
       for (let i = 0; i < targetDirs.length; i++) {
         const dir = targetDirs[i];
-        const repoName = dir.split("/").pop() || dir;
+        const repoName2 = dir.split("/").pop() || dir;
         try {
           process.stdout.write(
-            `\r  [${i + 1}/${targetDirs.length}] \u6B63\u5728\u66F4\u65B0: ${repoName}...`
+            `\r  [${i + 1}/${targetDirs.length}] \u6B63\u5728\u66F4\u65B0: ${repoName2}...`
           );
           await runCommand("pnpm tn:update --quiet", dir);
           successCount++;
@@ -3274,7 +4544,7 @@ var UpdateCommand = class extends BaseCommand {
           failCount++;
           console.log();
           this.logger.error(
-            `\u66F4\u65B0\u5931\u8D25: ${repoName} - ${error instanceof Error ? error.message : String(error)}`
+            `\u66F4\u65B0\u5931\u8D25: ${repoName2} - ${error instanceof Error ? error.message : String(error)}`
           );
         }
       }
@@ -3301,30 +4571,30 @@ var UpdateCommand = class extends BaseCommand {
    */
   async updateRootItem() {
     try {
-      const configContent = readFileSync6(ROOT_CONFIG_PATH, "utf-8");
-      const config = JSON.parse(configContent);
-      const readmePath = resolve2(ROOT_DIR_PATH, "README.md");
-      if (!existsSync9(readmePath)) {
+      const configContent = readFileSync7(ROOT_CONFIG_PATH, "utf-8");
+      const config2 = JSON.parse(configContent);
+      const readmePath = resolve3(ROOT_DIR_PATH, "README.md");
+      if (!existsSync10(readmePath)) {
         throw new Error("\u6839\u76EE\u5F55 README.md \u4E0D\u5B58\u5728");
       }
-      const readmeContent = readFileSync6(readmePath, "utf-8");
+      const readmeContent = readFileSync7(readmePath, "utf-8");
       const { completedCount } = parseReadmeCompletedNotes(readmeContent);
       const now = /* @__PURE__ */ new Date();
       const yearShort = String(now.getFullYear()).slice(-2);
       const monthStr = String(now.getMonth() + 1).padStart(2, "0");
       const currentKey = `${yearShort}.${monthStr}`;
       const completedNotesCount = {
-        ...config.root_item.completed_notes_count || {},
+        ...config2.root_item.completed_notes_count || {},
         [currentKey]: completedCount
       };
       const updatedAt = Date.now();
-      config.root_item = {
-        ...config.root_item,
+      config2.root_item = {
+        ...config2.root_item,
         completed_notes_count: completedNotesCount,
         updated_at: updatedAt
       };
-      delete config.root_item.completed_notes_count_last_month;
-      writeFileSync5(ROOT_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+      delete config2.root_item.completed_notes_count_last_month;
+      writeFileSync6(ROOT_CONFIG_PATH, JSON.stringify(config2, null, 2), "utf-8");
       if (!this.quiet) {
         this.logger.success(
           `root_item \u914D\u7F6E\u5DF2\u66F4\u65B0: ${currentKey} \u6708\u5B8C\u6210 ${completedCount} \u7BC7\u7B14\u8BB0`
@@ -3342,12 +4612,12 @@ var UpdateCommand = class extends BaseCommand {
 };
 
 // commands/update-completed-count/UpdateCompletedCountCommand.ts
-import { readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { execSync as execSync2 } from "child_process";
+import { readFileSync as readFileSync8, writeFileSync as writeFileSync7 } from "fs";
+import { execSync as execSync4 } from "child_process";
 var UpdateCompletedCountCommand = class extends BaseCommand {
+  updateAll = false;
   constructor() {
     super("update-completed-count");
-    this.updateAll = false;
   }
   /**
    * 设置是否更新所有知识库
@@ -3368,16 +4638,16 @@ var UpdateCompletedCountCommand = class extends BaseCommand {
   async updateCurrentRepo() {
     const startTime = Date.now();
     try {
-      const configContent = readFileSync7(ROOT_CONFIG_PATH, "utf-8");
-      const config = JSON.parse(configContent);
+      const configContent = readFileSync8(ROOT_CONFIG_PATH, "utf-8");
+      const config2 = JSON.parse(configContent);
       this.logger.info("\u5F00\u59CB\u66F4\u65B0\u5B8C\u6210\u7B14\u8BB0\u6570\u91CF\u5386\u53F2\u8BB0\u5F55...");
-      const completedNotesCountHistory = await this.getCompletedNotesCountHistory(config.root_item.created_at);
-      config.root_item = {
-        ...config.root_item,
+      const completedNotesCountHistory = await this.getCompletedNotesCountHistory(config2.root_item.created_at);
+      config2.root_item = {
+        ...config2.root_item,
         completed_notes_count: completedNotesCountHistory,
         updated_at: Date.now()
       };
-      writeFileSync6(ROOT_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+      writeFileSync7(ROOT_CONFIG_PATH, JSON.stringify(config2, null, 2), "utf-8");
       const duration = Date.now() - startTime;
       const monthKeys = Object.keys(completedNotesCountHistory);
       const currentKey = monthKeys[monthKeys.length - 1];
@@ -3412,10 +4682,10 @@ var UpdateCompletedCountCommand = class extends BaseCommand {
       let failCount = 0;
       for (let i = 0; i < targetDirs.length; i++) {
         const dir = targetDirs[i];
-        const repoName = dir.split("/").pop() || dir;
+        const repoName2 = dir.split("/").pop() || dir;
         try {
           process.stdout.write(
-            `\r  [${i + 1}/${targetDirs.length}] \u6B63\u5728\u66F4\u65B0: ${repoName}...`
+            `\r  [${i + 1}/${targetDirs.length}] \u6B63\u5728\u66F4\u65B0: ${repoName2}...`
           );
           await runCommand("pnpm tn:update-completed-count", dir);
           successCount++;
@@ -3423,7 +4693,7 @@ var UpdateCompletedCountCommand = class extends BaseCommand {
           failCount++;
           console.log();
           this.logger.error(
-            `\u66F4\u65B0\u5931\u8D25: ${repoName} - ${error instanceof Error ? error.message : String(error)}`
+            `\u66F4\u65B0\u5931\u8D25: ${repoName2} - ${error instanceof Error ? error.message : String(error)}`
           );
         }
       }
@@ -3518,7 +4788,7 @@ var UpdateCompletedCountCommand = class extends BaseCommand {
     const monthStr = String(lastDayOfMonth.getMonth() + 1).padStart(2, "0");
     const dayStr = String(lastDayOfMonth.getDate()).padStart(2, "0");
     const untilDate = `${yearStr}-${monthStr}-${dayStr} 23:59:59 +0800`;
-    const commitHash = execSync2(
+    const commitHash = execSync4(
       `git log --until="${untilDate}" --format=%H -1 -- README.md`,
       {
         cwd: ROOT_DIR_PATH,
@@ -3530,7 +4800,7 @@ var UpdateCompletedCountCommand = class extends BaseCommand {
     }
     let readmeContent;
     try {
-      readmeContent = execSync2(`git show ${commitHash}:README.md`, {
+      readmeContent = execSync4(`git show ${commitHash}:README.md`, {
         cwd: ROOT_DIR_PATH,
         encoding: "utf-8"
       });
@@ -3544,9 +4814,11 @@ var UpdateCompletedCountCommand = class extends BaseCommand {
 
 // commands/git/PushCommand.ts
 var PushCommand = class extends BaseCommand {
+  gitService;
+  timestampService;
+  pushAll = false;
   constructor() {
     super("push");
-    this.pushAll = false;
     this.gitService = new GitService();
     this.timestampService = new TimestampService();
   }
@@ -3610,9 +4882,10 @@ var PushCommand = class extends BaseCommand {
 
 // commands/git/PullCommand.ts
 var PullCommand = class extends BaseCommand {
+  gitService;
+  pullAll = false;
   constructor() {
     super("pull");
-    this.pullAll = false;
     this.gitService = new GitService();
   }
   /**
@@ -3638,9 +4911,10 @@ var PullCommand = class extends BaseCommand {
 
 // commands/git/SyncCommand.ts
 var SyncCommand = class extends BaseCommand {
+  gitService;
+  syncAll = false;
   constructor() {
     super("sync");
-    this.syncAll = false;
     this.gitService = new GitService();
   }
   /**
@@ -3668,6 +4942,11 @@ var SyncCommand = class extends BaseCommand {
 
 // commands/dev/DevCommand.ts
 var DevCommand = class extends BaseCommand {
+  fileWatcherService;
+  vitepressService;
+  noteManager;
+  noteIndexCache;
+  configManager;
   constructor() {
     super("dev");
     this.fileWatcherService = new FileWatcherService();
@@ -3690,10 +4969,10 @@ var DevCommand = class extends BaseCommand {
       this.fileWatcherService.start();
       const watcherElapsed = Date.now() - watcherStart;
       this.logger.success(`\u6587\u4EF6\u76D1\u542C\u670D\u52A1\u5DF2\u5C31\u7EEA\uFF0C\u8017\u65F6\uFF1A${watcherElapsed} ms`);
-      const port = this.configManager.get("port") || VitepressService.DEFAULT_DEV_PORT;
-      const repoName = this.configManager.get("repoName");
+      const port2 = this.configManager.get("port") || VitepressService.DEFAULT_DEV_PORT;
+      const repoName2 = this.configManager.get("repoName");
       this.logger.info(
-        `\u672C\u5730\u5F00\u53D1\u670D\u52A1\u5730\u5740\uFF1Ahttp://localhost:${port}/${repoName}/`
+        `\u672C\u5730\u5F00\u53D1\u670D\u52A1\u5730\u5740\uFF1Ahttp://localhost:${port2}/${repoName2}/`
       );
     } else {
       this.logger.error("\u542F\u52A8\u670D\u52A1\u5668\u5931\u8D25");
@@ -3703,6 +4982,7 @@ var DevCommand = class extends BaseCommand {
 
 // commands/build/BuildCommand.ts
 var BuildCommand = class extends BaseCommand {
+  vitepressService;
   constructor() {
     super("build");
     this.vitepressService = new VitepressService();
@@ -3716,6 +4996,7 @@ var BuildCommand = class extends BaseCommand {
 
 // commands/build/PreviewCommand.ts
 var PreviewCommand = class extends BaseCommand {
+  vitepressService;
   constructor() {
     super("preview");
     this.vitepressService = new VitepressService();
@@ -3735,6 +5016,8 @@ var PreviewCommand = class extends BaseCommand {
 import { createInterface } from "readline";
 import { v4 as uuidv42 } from "uuid";
 var CreateNoteCommand = class extends BaseCommand {
+  noteService;
+  readmeService;
   constructor() {
     super("create-notes");
     this.noteService = NoteService.getInstance();
@@ -3811,23 +5094,23 @@ var CreateNoteCommand = class extends BaseCommand {
       input: process.stdin,
       output: process.stdout
     });
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       rl.question("\n\u{1F4DD} \u8BF7\u8F93\u5165\u8981\u521B\u5EFA\u7684\u7B14\u8BB0\u6570\u91CF\uFF08\u9ED8\u8BA4\u4E3A 1\uFF09: ", (answer) => {
         rl.close();
         const trimmed = answer.trim();
         if (!trimmed) {
           this.logger.info("\u4F7F\u7528\u9ED8\u8BA4\u6570\u91CF: 1");
-          resolve3(1);
+          resolve4(1);
           return;
         }
         const num = parseInt(trimmed, 10);
         if (isNaN(num) || num < 1 || !Number.isInteger(num)) {
           this.logger.warn(`\u8F93\u5165 "${trimmed}" \u4E0D\u662F\u6709\u6548\u7684\u6B63\u6574\u6570\uFF0C\u4F7F\u7528\u9ED8\u8BA4\u503C: 1`);
-          resolve3(1);
+          resolve4(1);
           return;
         }
         this.logger.info(`\u5C06\u521B\u5EFA ${num} \u7BC7\u7B14\u8BB0`);
-        resolve3(num);
+        resolve4(num);
       });
     });
   }
@@ -3839,10 +5122,10 @@ var CreateNoteCommand = class extends BaseCommand {
       input: process.stdin,
       output: process.stdout
     });
-    return new Promise((resolve3) => {
+    return new Promise((resolve4) => {
       rl.question("\u8BF7\u8F93\u5165\u7B14\u8BB0\u6807\u9898: ", (answer) => {
         rl.close();
-        resolve3(answer.trim());
+        resolve4(answer.trim());
       });
     });
   }
@@ -3850,6 +5133,7 @@ var CreateNoteCommand = class extends BaseCommand {
 
 // commands/note/UpdateNoteConfigCommand.ts
 var UpdateNoteConfigCommand = class extends BaseCommand {
+  noteService;
   constructor() {
     super("update-note-config");
     this.noteService = NoteService.getInstance();
@@ -3881,26 +5165,28 @@ var UpdateNoteConfigCommand = class extends BaseCommand {
    * 更新笔记配置（可被外部调用）
    */
   async updateConfig(params) {
-    const { noteIndex, config } = 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, config);
+    await this.noteService.updateNoteConfig(noteIndex, config2);
     this.logger.info(`\u2705 \u7B14\u8BB0 ${noteIndex} \u914D\u7F6E\u5DF2\u66F4\u65B0:`);
-    if (config.done !== void 0)
-      this.logger.info(`  - \u5B8C\u6210\u72B6\u6001: ${config.done}`);
-    if (config.enableDiscussions !== void 0)
-      this.logger.info(`  - \u8BC4\u8BBA\u72B6\u6001: ${config.enableDiscussions}`);
-    if (config.description !== void 0)
-      this.logger.info(`  - \u7B14\u8BB0\u7B80\u4ECB: ${config.description || "(\u7A7A)"}`);
+    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 readFileSync8, writeFileSync as writeFileSync7 } from "fs";
-import { join as join9 } from "path";
+import { existsSync as existsSync11, renameSync, readFileSync as readFileSync9, writeFileSync as writeFileSync8 } from "fs";
+import { join as join11 } from "path";
 var RenameNoteCommand = class extends BaseCommand {
+  noteService;
+  readmeService;
   constructor() {
     super("rename-note");
     this.noteService = NoteService.getInstance();
@@ -3934,8 +5220,8 @@ var RenameNoteCommand = class extends BaseCommand {
       throw new Error(validation.error || "\u6807\u9898\u683C\u5F0F\u65E0\u6548");
     }
     const newDirName = `${noteIndex}. ${newTitle.trim()}`;
-    const newPath = join9(NOTES_PATH, newDirName);
-    if (existsSync10(newPath)) {
+    const newPath = join11(NOTES_PATH, newDirName);
+    if (existsSync11(newPath)) {
       throw new Error(`\u76EE\u6807\u6587\u4EF6\u5939\u5DF2\u5B58\u5728: ${newDirName}`);
     }
     try {
@@ -3950,9 +5236,9 @@ var RenameNoteCommand = class extends BaseCommand {
     }
     try {
       this.logger.info("\u6B63\u5728\u66F4\u65B0\u7B14\u8BB0\u5185\u90E8\u6807\u9898...");
-      const readmePath = join9(newPath, "README.md");
-      if (existsSync10(readmePath)) {
-        const content = readFileSync8(readmePath, "utf-8");
+      const readmePath = join11(newPath, "README.md");
+      if (existsSync11(readmePath)) {
+        const content = readFileSync9(readmePath, "utf-8");
         const lines = content.split("\n");
         let h1Index = -1;
         for (let i = 0; i < lines.length; i++) {
@@ -3968,7 +5254,7 @@ var RenameNoteCommand = class extends BaseCommand {
             REPO_NOTES_URL
           );
           lines[h1Index] = newH1;
-          writeFileSync7(readmePath, lines.join("\n"), "utf-8");
+          writeFileSync8(readmePath, lines.join("\n"), "utf-8");
           this.logger.success("\u2705 \u7B14\u8BB0\u6807\u9898\u5DF2\u66F4\u65B0");
         } else {
           this.logger.warn(
@@ -3991,6 +5277,7 @@ var RenameNoteCommand = class extends BaseCommand {
 
 // commands/maintenance/SyncCoreCommand.ts
 var SyncCoreCommand = class extends BaseCommand {
+  syncCoreService;
   constructor() {
     super("sync-core");
     this.syncCoreService = new SyncCoreService();
@@ -4002,6 +5289,7 @@ var SyncCoreCommand = class extends BaseCommand {
 
 // commands/maintenance/FixTimestampsCommand.ts
 var FixTimestampsCommand = class extends BaseCommand {
+  timestampService;
   constructor() {
     super("fix-timestamps");
     this.timestampService = new TimestampService();