@tnotesjs/core 0.2.0 → 0.2.2

package/dist/cli/index.js

@@ -0,0 +1,986 @@
+#!/usr/bin/env node
+import {
+  BaseCommand,
+  COMMAND_DESCRIPTIONS,
+  COMMAND_NAMES,
+  COMMAND_OPTIONS,
+  DEFAULT_DESCRIPTION,
+  DEFAULT_PORT,
+  FileWatcherService,
+  GitManager,
+  GitService,
+  InitSubRepoService,
+  NoteIndexCache,
+  NoteManager,
+  NoteService,
+  ROOT_CONFIG_PATH,
+  ROOT_DIR_PATH,
+  ROOT_README_PATH,
+  ROOT_TOC_PATH,
+  ReadmeService,
+  RenameNoteCommand,
+  TimestampService,
+  TocService,
+  UpdateNoteConfigCommand,
+  VitepressService,
+  buildFolderTocLine,
+  buildInitContext,
+  buildManualSteps,
+  buildTocLine,
+  createLogger,
+  defaultDisplayName,
+  getInitializedConfigPath,
+  handleError,
+  isAlreadyInitialized,
+  logger,
+  migrateReadmeToToc,
+  parseArgs,
+  parseReadmeCompletedNotes,
+  parseTocCompletedNotes,
+  processTocEmptyLines,
+  resolveNoteFromIndex,
+  runCommand,
+  validatePort,
+  validateTopic
+} from "../chunk-5QN44ES5.js";
+import {
+  ConfigManager,
+  getConfigManager
+} from "../chunk-5Y5IYS6C.js";
+
+// commands/update/UpdateCommand.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+var UpdateCommand = class extends BaseCommand {
+  constructor() {
+    super("update");
+    this.quiet = false;
+    this.readmeService = ReadmeService.getInstance();
+    this.noteService = NoteService.getInstance();
+  }
+  /**
+   * 设置 quiet 模式
+   *
+   * 在 quiet 模式下，只显示 WARN 级别以上的日志
+   */
+  setQuiet(quiet) {
+    this.quiet = quiet;
+    if (quiet) {
+      logger.setLevel(2 /* WARN */);
+    } else {
+      logger.setLevel(1 /* INFO */);
+    }
+  }
+  async run() {
+    await this.updateCurrentRepo();
+  }
+  /**
+   * 更新当前知识库
+   */
+  async updateCurrentRepo() {
+    const startTime = Date.now();
+    const notes = this.noteService.getAllNotes();
+    if (!this.quiet) {
+      this.logger.info("\u6B63\u5728\u4FEE\u6B63\u7B14\u8BB0\u6807\u9898...");
+    }
+    const fixedCount = await this.noteService.fixAllNoteTitles(notes);
+    if (!this.quiet && fixedCount > 0) {
+      this.logger.success(`\u4FEE\u6B63\u4E86 ${fixedCount} \u4E2A\u7B14\u8BB0\u6807\u9898`);
+    }
+    await this.readmeService.updateAllReadmes({ notes });
+    await this.updateRootItem();
+    const duration = Date.now() - startTime;
+    if (this.quiet) {
+      this.logger.success(`\u77E5\u8BC6\u5E93\u66F4\u65B0\u5B8C\u6210 (${duration}ms)`);
+    } else {
+      this.logger.success("\u77E5\u8BC6\u5E93\u66F4\u65B0\u5B8C\u6210");
+    }
+  }
+  /**
+   * 更新 root_item 配置
+   * 更新当前月份的完成笔记数量，并自动补齐从最后已有月份到当前月份之间的所有缺失月份。
+   */
+  async updateRootItem() {
+    try {
+      const configContent = readFileSync(ROOT_CONFIG_PATH, "utf-8");
+      const config = JSON.parse(configContent);
+      if (!existsSync(ROOT_TOC_PATH)) {
+        throw new Error("\u6839\u76EE\u5F55 TOC.md \u4E0D\u5B58\u5728");
+      }
+      const tocContent = readFileSync(ROOT_TOC_PATH, "utf-8");
+      const { completedCount } = parseTocCompletedNotes(tocContent);
+      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 existing = { ...config.root_item.completed_notes_count || {} };
+      const _countsBeforeFix = Object.keys(existing).length;
+      existing[currentKey] = completedCount;
+      const fixed = fillMissingMonthGaps(existing, currentKey);
+      config.root_item = {
+        ...config.root_item,
+        completed_notes_count: fixed
+      };
+      delete config.root_item.completed_notes_count_last_month;
+      writeFileSync(ROOT_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+      if (!this.quiet) {
+        const filledCount = Object.keys(fixed).length - _countsBeforeFix;
+        const filledMsg = filledCount > 0 ? `\uFF0C\u8865\u9F50 ${filledCount} \u4E2A\u7F3A\u5931\u6708\u4EFD` : "";
+        this.logger.success(
+          `root_item \u914D\u7F6E\u5DF2\u66F4\u65B0: ${currentKey} \u6708\u5B8C\u6210 ${completedCount} \u7BC7\u7B14\u8BB0${filledMsg}`
+        );
+      }
+    } catch (error) {
+      if (!this.quiet) {
+        this.logger.error(
+          `\u66F4\u65B0 root_item \u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      throw error;
+    }
+  }
+};
+function fillMissingMonthGaps(counts, currentKey) {
+  const existingKeys = Object.keys(counts).sort();
+  const result = {};
+  const keySet = new Set(existingKeys);
+  keySet.add(currentKey);
+  const allKeys = Array.from(keySet).sort();
+  let prevValue = 0;
+  let lastKey = null;
+  for (const key of allKeys) {
+    if (lastKey !== null) {
+      const missing = generateMissingMonthKeys(lastKey, key);
+      for (const midKey of missing) {
+        result[midKey] = prevValue;
+      }
+    }
+    result[key] = counts[key] ?? prevValue;
+    prevValue = result[key];
+    lastKey = key;
+  }
+  return result;
+}
+function generateMissingMonthKeys(fromKey, toKey) {
+  const parseKey = (key) => {
+    const [yy, mm] = key.split(".").map(Number);
+    return { year: 2e3 + yy, month: mm };
+  };
+  const from = parseKey(fromKey);
+  const to = parseKey(toKey);
+  const missing = [];
+  let year = from.year;
+  let month = from.month;
+  while (true) {
+    month++;
+    if (month > 12) {
+      month = 1;
+      year++;
+    }
+    const shortYear = String(year).slice(-2);
+    const paddedMonth = String(month).padStart(2, "0");
+    const candidateKey = `${shortYear}.${paddedMonth}`;
+    if (candidateKey === toKey) break;
+    if (year > to.year || year === to.year && month > to.month) break;
+    missing.push(candidateKey);
+  }
+  return missing;
+}
+
+// commands/git/PushCommand.ts
+var PushCommand = class extends BaseCommand {
+  constructor() {
+    super("push");
+    this.gitManager = new GitManager(ROOT_DIR_PATH);
+    this.gitService = new GitService();
+    this.timestampService = new TimestampService();
+  }
+  async run() {
+    try {
+      this.logger.info("\u68C0\u67E5\u662F\u5426\u6709\u66F4\u6539...");
+      const status = await this.gitManager.getStatus();
+      const hasPendingCommits = (status.ahead ?? 0) > 0;
+      if (!status.hasChanges && !hasPendingCommits) {
+        this.logger.info("\u6CA1\u6709\u66F4\u6539\u9700\u8981\u63A8\u9001");
+        return;
+      }
+      const force = this.options.force === true;
+      if (force) {
+        this.logger.warn("\u4F7F\u7528\u5F3A\u5236\u63A8\u9001\u6A21\u5F0F (--force)");
+      }
+      if (status.hasChanges) {
+        this.logger.info(
+          `\u68C0\u6D4B\u5230 ${status.files.length} \u4E2A\u53D8\u66F4\u6587\u4EF6\uFF0C\u6B63\u5728\u63D0\u4EA4...`
+        );
+        const commitMessage = this.gitService.generateCommitMessage();
+        await runCommand("git add -A", ROOT_DIR_PATH);
+        await runCommand(`git commit -m "${commitMessage}"`, ROOT_DIR_PATH);
+        this.logger.info("\u4FEE\u590D\u7B14\u8BB0\u65F6\u95F4\u6233...");
+        await this.timestampService.fixAllTimestamps(false);
+        const afterFixStatus = await runCommand(
+          "git -c core.quotePath=false status --porcelain",
+          ROOT_DIR_PATH
+        );
+        const hasTimestampChanges = afterFixStatus.split(/\r?\n/).filter(Boolean).some((line) => line.includes(".tnotes.json"));
+        if (hasTimestampChanges) {
+          this.logger.info("\u5C06\u65F6\u95F4\u6233\u53D8\u66F4\u5408\u5E76\u5230 commit...");
+          await runCommand("git add -u", ROOT_DIR_PATH);
+          await runCommand("git commit --amend --no-edit", ROOT_DIR_PATH);
+        }
+      } else {
+        this.logger.info(`\u68C0\u6D4B\u5230 ${status.ahead} \u4E2A\u672A\u63A8\u9001\u7684\u63D0\u4EA4\uFF0C\u76F4\u63A5\u63A8\u9001...`);
+      }
+      this.logger.info("\u6B63\u5728\u63A8\u9001\u5230\u8FDC\u7A0B\u4ED3\u5E93...");
+      const pushCmd = force ? "git push --force" : "git push";
+      await runCommand(pushCmd, ROOT_DIR_PATH);
+      this.logger.success("\u63A8\u9001\u5B8C\u6210");
+    } catch (error) {
+      this.logger.error("\u63A8\u9001\u5931\u8D25:", error);
+      throw error;
+    }
+  }
+};
+
+// commands/git/PullCommand.ts
+var PullCommand = class extends BaseCommand {
+  constructor() {
+    super("pull");
+    this.gitService = new GitService();
+  }
+  async run() {
+    this.logger.info("\u6B63\u5728\u4ECE\u8FDC\u7A0B\u4ED3\u5E93\u62C9\u53D6...");
+    await this.gitService.pull();
+    this.logger.success("\u62C9\u53D6\u5B8C\u6210");
+  }
+};
+
+// commands/build/BuildCommand.ts
+var BuildCommand = class extends BaseCommand {
+  constructor() {
+    super("build");
+    this.vitepressService = new VitepressService();
+  }
+  async run() {
+    this.logger.info("\u5F00\u59CB\u6784\u5EFA\u77E5\u8BC6\u5E93...");
+    await this.vitepressService.build();
+    this.logger.success("\u77E5\u8BC6\u5E93\u6784\u5EFA\u5B8C\u6210");
+  }
+};
+
+// commands/build/PreviewCommand.ts
+var PreviewCommand = class extends BaseCommand {
+  constructor() {
+    super("preview");
+    this.vitepressService = new VitepressService();
+  }
+  async run() {
+    this.logger.info("\u542F\u52A8\u9884\u89C8\u670D\u52A1\u5668...");
+    const pid = await this.vitepressService.preview();
+    if (pid) {
+      this.logger.success(`\u9884\u89C8\u670D\u52A1\u5668\u5DF2\u542F\u52A8 (PID: ${pid})`);
+    } else {
+      this.logger.error("\u542F\u52A8\u9884\u89C8\u670D\u52A1\u5668\u5931\u8D25");
+    }
+  }
+};
+
+// commands/dev/DevCommand.ts
+var DevCommand = class extends BaseCommand {
+  constructor() {
+    super("dev");
+    this.configManager = ConfigManager.getInstance();
+    this.fileWatcherService = new FileWatcherService();
+    this.noteIndexCache = NoteIndexCache.getInstance();
+    this.noteManager = NoteManager.getInstance();
+    this.tocService = TocService.getInstance();
+    this.vitepressService = new VitepressService();
+  }
+  async run() {
+    const notes = this.noteManager.scanNotes();
+    this.logger.info(`\u626B\u63CF\u5230 ${notes.length} \u7BC7\u7B14\u8BB0`);
+    this.noteIndexCache.initialize(notes);
+    this.tocService.ensureTocExists();
+    await this.tocService.regenerateSidebar(notes);
+    const result = await this.vitepressService.startServer();
+    if (result) {
+      const versionInfo = result.version ? `\uFF08v${result.version}\uFF09` : "";
+      this.logger.success(
+        `VitePress \u670D\u52A1${versionInfo}\u5DF2\u5C31\u7EEA\uFF0C\u8017\u65F6\uFF1A${result.elapsed} ms`
+      );
+      const watcherStart = Date.now();
+      this.fileWatcherService.start();
+      const watcherElapsed = Date.now() - watcherStart;
+      this.logger.success(`\u6587\u4EF6\u76D1\u542C\u670D\u52A1\u5DF2\u5C31\u7EEA\uFF0C\u8017\u65F6\uFF1A${watcherElapsed} ms`);
+      const 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:${port2}/${repoName2}/`
+      );
+    } else {
+      this.logger.error("\u542F\u52A8\u670D\u52A1\u5668\u5931\u8D25");
+    }
+  }
+};
+
+// commands/init-sub-repo/InitSubRepoCommand.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { join, dirname } from "path";
+import { createInterface } from "readline";
+import { fileURLToPath } from "url";
+import { v4 as uuidv4 } from "uuid";
+function readCoreVersion() {
+  const moduleDir = dirname(fileURLToPath(import.meta.url));
+  let dir = moduleDir;
+  while (dir !== dirname(dir)) {
+    const pkgPath = join(dir, "package.json");
+    try {
+      const pkg = JSON.parse(readFileSync2(pkgPath, "utf-8"));
+      if (pkg.name === "@tnotesjs/core" && pkg.version) return pkg.version;
+    } catch {
+    }
+    dir = dirname(dir);
+  }
+  return "0.1.28";
+}
+var InitSubRepoCommand = class extends BaseCommand {
+  constructor() {
+    super("init-sub-repo");
+    this.rootPath = process.cwd();
+  }
+  async run() {
+    if (isAlreadyInitialized(this.rootPath)) {
+      const configPath = getInitializedConfigPath(this.rootPath);
+      this.logger.info(
+        `\u68C0\u6D4B\u5230 .tnotes.json \u914D\u7F6E\u6587\u4EF6\uFF1A${configPath}\uFF0C\u5F53\u524D\u4ED3\u5E93\u5DF2\u7ECF\u662F\u4E00\u4E2A TNotes \u77E5\u8BC6\u5E93`
+      );
+      return;
+    }
+    this.logger.info("\u521D\u59CB\u5316 TNotes \u5B50\u77E5\u8BC6\u5E93");
+    this.logger.info("");
+    const input = await this.promptForInput();
+    const ctx = buildInitContext(input);
+    this.logger.info("");
+    this.logger.info("\u5373\u5C06\u521B\u5EFA\u4EE5\u4E0B\u77E5\u8BC6\u5E93\uFF1A");
+    this.logger.info(`  \u4ED3\u5E93\u540D\uFF1A${ctx.repoName}`);
+    this.logger.info(`  \u5C55\u793A\u540D\uFF1A${ctx.displayName}`);
+    this.logger.info(`  \u7AEF\u53E3\uFF1A${ctx.port}`);
+    this.logger.info(`  \u63CF\u8FF0\uFF1A${ctx.description}`);
+    this.logger.info("");
+    const confirmed = await this.promptConfirm("\u786E\u8BA4\u521D\u59CB\u5316\uFF1F [Y/n] ");
+    if (!confirmed) {
+      this.logger.info("\u5DF2\u53D6\u6D88\u521D\u59CB\u5316");
+      return;
+    }
+    const service = InitSubRepoService.fromModuleUrl(import.meta.url, this.rootPath);
+    const result = service.writeScaffold(input);
+    if (result.created.length > 0) {
+      this.logger.success(`\u5DF2\u521B\u5EFA ${result.created.length} \u4E2A\u6587\u4EF6\uFF1A`);
+      for (const file of result.created) {
+        this.logger.info(`  + ${file}`);
+      }
+    }
+    if (result.updated.length > 0) {
+      this.logger.success(`\u5DF2\u66F4\u65B0 ${result.updated.length} \u4E2A\u6587\u4EF6\uFF1A`);
+      for (const file of result.updated) {
+        this.logger.info(`  ~ ${file}`);
+      }
+    }
+    if (result.skipped.length > 0) {
+      this.logger.warn(`\u5DF2\u8DF3\u8FC7 ${result.skipped.length} \u4E2A\u5DF2\u5B58\u5728\u6587\u4EF6\uFF1A`);
+      for (const file of result.skipped) {
+        this.logger.info(`  - ${file}`);
+      }
+    }
+    getConfigManager().clearCache();
+    try {
+      this.logger.info("");
+      this.logger.info("\u6B63\u5728\u89C4\u8303\u5316 TOC.md \u5E76\u751F\u6210 sidebar.json...");
+      const noteService = NoteService.getInstance();
+      const tocService = TocService.getInstance();
+      const notes = noteService.getAllNotes();
+      await tocService.normalizeToc(notes);
+      await tocService.regenerateSidebar(notes);
+      this.logger.success("sidebar.json \u5DF2\u751F\u6210");
+    } catch (error) {
+      this.logger.warn(
+        `\u81EA\u52A8 update \u5931\u8D25\uFF08\u53EF\u7A0D\u540E\u624B\u52A8\u6267\u884C pnpm tn:update\uFF09\uFF1A${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    this.logger.info("");
+    this.logger.success("\u5B50\u77E5\u8BC6\u5E93\u521D\u59CB\u5316\u5B8C\u6210\uFF01");
+    this.logger.info("");
+    this.logger.info("\u8BF7\u624B\u52A8\u5B8C\u6210\u4EE5\u4E0B\u6B65\u9AA4\uFF1A");
+    for (const [index, step] of buildManualSteps(ctx).entries()) {
+      this.logger.info(`  ${index + 1}. ${step}`);
+    }
+  }
+  async promptForInput() {
+    const topic = await this.promptTopic();
+    const displayName = await this.promptDisplayName(topic);
+    const port2 = await this.promptPort();
+    const description = await this.promptDescription();
+    return {
+      topic,
+      displayName,
+      port: port2,
+      description,
+      repoUuid: uuidv4(),
+      noteUuid: uuidv4(),
+      coreVersion: readCoreVersion()
+    };
+  }
+  async promptTopic() {
+    while (true) {
+      const answer = await this.ask("\u8BF7\u8F93\u5165 topic\uFF08\u5982 react\uFF0C\u5C06\u751F\u6210 TNotes.react\uFF09: ");
+      const error = validateTopic(answer);
+      if (error) {
+        this.logger.warn(error);
+        continue;
+      }
+      return answer.trim();
+    }
+  }
+  async promptDisplayName(topic) {
+    const fallback = defaultDisplayName(topic);
+    const answer = await this.ask(
+      `\u8BF7\u8F93\u5165\u5C55\u793A\u540D\uFF08\u7528\u4E8E\u9996\u9875 hero\uFF0C\u9ED8\u8BA4 ${fallback}\uFF09: `
+    );
+    return answer.trim() || fallback;
+  }
+  async promptPort() {
+    const answer = await this.ask(`\u8BF7\u8F93\u5165 dev \u7AEF\u53E3\uFF08\u9ED8\u8BA4 ${DEFAULT_PORT}\uFF09: `);
+    const { port: port2, error } = validatePort(answer);
+    if (error) this.logger.warn(error);
+    return port2;
+  }
+  async promptDescription() {
+    const answer = await this.ask(
+      `\u8BF7\u8F93\u5165\u4ED3\u5E93\u63CF\u8FF0\uFF08\u9ED8\u8BA4\uFF1A${DEFAULT_DESCRIPTION}\uFF09: `
+    );
+    return answer.trim() || DEFAULT_DESCRIPTION;
+  }
+  async promptConfirm(question) {
+    const answer = await this.ask(question);
+    const normalized = answer.trim().toLowerCase();
+    return normalized === "" || normalized === "y" || normalized === "yes";
+  }
+  ask(question) {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer);
+      });
+    });
+  }
+};
+
+// commands/init-toc/InitTocCommand.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+var InitTocCommand = class extends BaseCommand {
+  constructor() {
+    super("init-toc");
+    this.noteManager = NoteManager.getInstance();
+    this.tocService = TocService.getInstance();
+  }
+  async run() {
+    if (!existsSync2(ROOT_README_PATH)) {
+      throw new Error(`README.md \u4E0D\u5B58\u5728: ${ROOT_README_PATH}`);
+    }
+    const readmeContent = readFileSync3(ROOT_README_PATH, "utf-8");
+    const notes = this.noteManager.scanNotes();
+    const { entries, warnings } = migrateReadmeToToc(readmeContent);
+    for (const warning of warnings) {
+      this.logger.warn(warning);
+    }
+    const lines = [];
+    let skipped = 0;
+    for (const entry of entries) {
+      if (entry.kind === "folder") {
+        lines.push(buildFolderTocLine(entry.folderTitle, entry.indent));
+        continue;
+      }
+      const note = resolveNoteFromIndex(entry.noteIndex, notes);
+      if (!note) {
+        skipped++;
+        this.logger.warn(
+          `\u8DF3\u8FC7 README \u4E2D\u5B58\u5728\u4F46 notes/ \u76EE\u5F55\u4E2D\u4E0D\u5B58\u5728\u7684\u7B14\u8BB0: ${entry.noteIndex}`
+        );
+        continue;
+      }
+      lines.push(buildTocLine(note, entry.indent, entry.completed));
+    }
+    if (lines.length === 0) {
+      throw new Error(
+        "\u672A\u80FD\u4ECE README.md \u89E3\u6790\u5230\u4EFB\u4F55\u6709\u6548\u7B14\u8BB0\u6761\u76EE\uFF0CTOC.md \u672A\u5199\u5165"
+      );
+    }
+    const content = processTocEmptyLines(lines).join("\n");
+    writeFileSync2(ROOT_TOC_PATH, content, "utf-8");
+    await this.tocService.regenerateSidebar(notes);
+    this.logger.success(
+      `TOC.md \u5DF2\u4ECE README.md \u521D\u59CB\u5316\uFF08${lines.length} \u6761\u7B14\u8BB0${skipped > 0 ? `\uFF0C\u8DF3\u8FC7 ${skipped} \u6761` : ""}\uFF09`
+    );
+    this.logger.info(`\u8F93\u51FA\u8DEF\u5F84: ${ROOT_TOC_PATH}`);
+    this.logger.info(
+      "\u8FC7\u6E21\u547D\u4EE4 init-toc \u4EC5\u5728 v0.2.x \u63D0\u4F9B\uFF0Cv0.3.x \u5C06\u79FB\u9664\uFF1B\u540E\u7EED\u8BF7\u4F7F\u7528 TOC.md + pnpm tn:update"
+    );
+    const listedIndexes = new Set(
+      entries.filter((e) => e.kind === "note").map((e) => e.noteIndex)
+    );
+    const missingInReadme = notes.filter((n) => !listedIndexes.has(n.index));
+    if (missingInReadme.length > 0) {
+      this.logger.info(
+        `README \u4E2D\u672A\u5217\u51FA ${missingInReadme.length} \u7BC7\u7B14\u8BB0\uFF0C\u53EF\u6267\u884C pnpm tn:update \u8FFD\u52A0\u5230 TOC.md`
+      );
+    }
+  }
+};
+
+// commands/maintenance/FixTimestampsCommand.ts
+var FixTimestampsCommand = class extends BaseCommand {
+  constructor() {
+    super("fix-timestamps");
+    this.timestampService = new TimestampService();
+  }
+  async run() {
+    this.logger.info("\u5F00\u59CB\u4FEE\u590D\u6240\u6709\u7B14\u8BB0\u7684\u65F6\u95F4\u6233...");
+    this.logger.info("\u{1F4CC} \u6B64\u64CD\u4F5C\u4F1A\u5C06\u6240\u6709\u65F6\u95F4\u6233\u66F4\u65B0\u4E3A git \u771F\u5B9E\u65F6\u95F4");
+    this.logger.info("");
+    const result = await this.timestampService.fixAllTimestamps(true);
+    this.logger.info("");
+    this.logger.info("\u{1F4CA} \u4FEE\u590D\u7EDF\u8BA1:");
+    this.logger.info(
+      `  - \u6839\u914D\u7F6E\u6587\u4EF6: ${result.rootConfigFixed ? "\u5DF2\u4FEE\u590D" : "\u65E0\u9700\u4FEE\u590D"}`
+    );
+    this.logger.info(`  - \u603B\u7B14\u8BB0\u6570: ${result.total}`);
+    this.logger.info(`  - \u5DF2\u4FEE\u590D: ${result.fixed}`);
+    this.logger.info(`  - \u8DF3\u8FC7: ${result.skipped}`);
+    this.logger.info("");
+    if (result.fixed > 0 || result.rootConfigFixed) {
+      this.logger.success(
+        `\u2705 \u6210\u529F\u4FEE\u590D ${result.fixed} \u4E2A\u7B14\u8BB0${result.rootConfigFixed ? " + \u6839\u914D\u7F6E\u6587\u4EF6" : ""}\u7684\u65F6\u95F4\u6233\uFF01`
+      );
+      this.logger.info("\u{1F4A1} \u63D0\u793A: \u8FD0\u884C pnpm tn:push \u63D0\u4EA4\u66F4\u6539");
+    } else {
+      this.logger.success("\u2705 \u6240\u6709\u65F6\u95F4\u6233\u5747\u5DF2\u6B63\u786E\uFF01");
+    }
+  }
+};
+
+// commands/misc/HelpCommand.ts
+var COMMAND_CATEGORIES = {
+  \u5F00\u53D1\u548C\u6784\u5EFA: [COMMAND_NAMES.DEV, COMMAND_NAMES.BUILD, COMMAND_NAMES.PREVIEW],
+  \u5185\u5BB9\u7BA1\u7406: [
+    COMMAND_NAMES.UPDATE,
+    COMMAND_NAMES.UPDATE_COMPLETED_COUNT,
+    COMMAND_NAMES.CREATE_NOTES
+  ],
+  "Git \u64CD\u4F5C": [COMMAND_NAMES.PUSH, COMMAND_NAMES.PULL],
+  "\u8FC1\u79FB\uFF08v0.2.x \u8FC7\u6E21\uFF09": [COMMAND_NAMES.INIT_TOC],
+  \u521D\u59CB\u5316: [COMMAND_NAMES.INIT_SUB_REPO],
+  \u5176\u4ED6: [COMMAND_NAMES.FIX_TIMESTAMPS, COMMAND_NAMES.HELP]
+};
+var COMMAND_OPTIONS_INFO = {
+  [COMMAND_OPTIONS.QUIET]: {
+    description: "\u9759\u9ED8\u6A21\u5F0F",
+    applicableTo: "update"
+  },
+  [COMMAND_OPTIONS.FORCE]: {
+    description: "\u5F3A\u5236\u63A8\u9001",
+    applicableTo: "push"
+  }
+};
+var HelpCommand = class extends BaseCommand {
+  constructor() {
+    super("help");
+    this.logger = createLogger("help", {
+      timestamp: false,
+      level: process.env.DEBUG ? 0 /* DEBUG */ : 1 /* INFO */
+    });
+  }
+  async run() {
+    this.logger.info("TNotes \u547D\u4EE4\u884C\u5DE5\u5177");
+    this.logger.info("");
+    this.logger.info("\u7528\u6CD5\uFF1Apnpm tn:<command> # \u63A8\u8350");
+    this.logger.info("\u6216\u8005\uFF1Anpx tsx ./.vitepress/tnotes/index.ts --<command>");
+    this.logger.info("");
+    this.logger.info("\u53EF\u7528\u547D\u4EE4\uFF1A");
+    this.logger.info("");
+    for (const [category, cmdNames] of Object.entries(COMMAND_CATEGORIES)) {
+      this.logger.info(`  ${category}:`);
+      for (const cmdName of cmdNames) {
+        const description = COMMAND_DESCRIPTIONS[cmdName];
+        const paddingLength = Math.max(25 - cmdName.length, 1);
+        const padding = " ".repeat(paddingLength);
+        this.logger.info(`    --${cmdName}${padding}${description}`);
+      }
+      this.logger.info("");
+    }
+    this.logger.info("\u793A\u4F8B\uFF1A");
+    this.logger.info("  npx tsx ./.vitepress/tnotes/index.ts --dev");
+    this.logger.info("  pnpm tn:build");
+    this.logger.info("  pnpm tn:create-notes     # \u6279\u91CF\u521B\u5EFA\u7B14\u8BB0");
+    this.logger.info("  pnpm tn:update");
+    this.logger.info(
+      "  pnpm tn:init-toc              # v0.1.x \u2192 v0.2.x\uFF1A\u4ECE README.md \u751F\u6210 TOC.md"
+    );
+    this.logger.info(
+      "  pnpm tn:update-completed-count           # \u751F\u6210\u5F53\u524D\u77E5\u8BC6\u5E93\u6700\u8FD1 12 \u4E2A\u6708\u7684\u5B8C\u6210\u7B14\u8BB0\u6570\u91CF\u7EDF\u8BA1"
+    );
+    this.logger.info("");
+    this.logger.info("\u53C2\u6570\uFF1A");
+    for (const [option, info] of Object.entries(COMMAND_OPTIONS_INFO)) {
+      const paddingLength = Math.max(13 - option.length, 1);
+      const padding = " ".repeat(paddingLength);
+      this.logger.info(
+        `  --${option}${padding}${info.description} (\u9002\u7528\u4E8E ${info.applicableTo})`
+      );
+    }
+    this.logger.info("");
+    this.logger.info("\u73AF\u5883\u53D8\u91CF\uFF1A");
+    this.logger.info("  DEBUG=1        \u542F\u7528\u8C03\u8BD5\u6A21\u5F0F\uFF0C\u663E\u793A\u8BE6\u7EC6\u65E5\u5FD7");
+    this.logger.info("");
+    this.logger.info("\u66F4\u591A\u4FE1\u606F\u8BF7\u67E5\u770B: .vitepress/tnotes/README.md");
+  }
+};
+
+// commands/note/CreateNoteCommand.ts
+import { createInterface as createInterface2 } from "readline";
+import { v4 as uuidv42 } from "uuid";
+var CreateNoteCommand = class extends BaseCommand {
+  constructor() {
+    super("create-notes");
+    this.noteService = NoteService.getInstance();
+    this.readmeService = ReadmeService.getInstance();
+  }
+  async run() {
+    this.logger.info("\u521B\u5EFA\u65B0\u7B14\u8BB0...");
+    const count = await this.promptForCount();
+    let successCount = 0;
+    let failCount = 0;
+    const createdNotes = [];
+    const existingNotes = this.noteService.getAllNotes();
+    const usedIndexes = /* @__PURE__ */ new Set();
+    for (const note of existingNotes) {
+      const index = parseInt(note.index, 10);
+      if (!isNaN(index) && index >= 1 && index <= 9999) {
+        usedIndexes.add(index);
+      }
+    }
+    for (let i = 1; i <= count; i++) {
+      try {
+        let title;
+        if (count === 1) {
+          title = await this.promptForTitle();
+        } else {
+          title = `new`;
+          this.logger.info(`[${i}/${count}] \u521B\u5EFA\u7B14\u8BB0: ${title}`);
+        }
+        const configId = uuidv42();
+        const note = await this.noteService.createNote({
+          title: title || `new`,
+          enableDiscussions: false,
+          configId,
+          // 传递 UUID 作为配置 ID（跨知识库唯一）
+          usedIndexes
+          // 传入已使用编号集合，避免重复扫描
+        });
+        const newIndex = parseInt(note.index, 10);
+        if (!isNaN(newIndex)) {
+          usedIndexes.add(newIndex);
+        }
+        createdNotes.push(note.dirName);
+        successCount++;
+        if (count === 1) {
+          this.logger.success(`\u7B14\u8BB0\u521B\u5EFA\u6210\u529F: ${note.dirName}`);
+          this.logger.info(`\u7B14\u8BB0\u8DEF\u5F84: ${note.path}`);
+          this.logger.info(`\u7B14\u8BB0\u7F16\u53F7: ${note.index}`);
+          this.logger.info(`\u914D\u7F6EID: ${configId}`);
+        } else {
+          this.logger.success(`[${i}/${count}] \u521B\u5EFA\u6210\u529F: ${note.dirName}`);
+        }
+      } catch (error) {
+        failCount++;
+        this.logger.error(`[${i}/${count}] \u521B\u5EFA\u5931\u8D25`, error);
+      }
+    }
+    if (count > 1) {
+      console.log("");
+      this.logger.info(
+        `\u{1F4CA} \u521B\u5EFA\u5B8C\u6210: \u6210\u529F ${successCount} \u7BC7, \u5931\u8D25 ${failCount} \u7BC7`
+      );
+    }
+    if (successCount > 0) {
+      this.logger.info("\u6B63\u5728\u66F4\u65B0\u77E5\u8BC6\u5E93\u7D22\u5F15...");
+      await this.readmeService.updateAllReadmes();
+      this.logger.success("\u77E5\u8BC6\u5E93\u7D22\u5F15\u66F4\u65B0\u5B8C\u6210");
+    }
+  }
+  /**
+   * 提示用户输入要创建的笔记数量
+   */
+  async promptForCount() {
+    const rl = createInterface2({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      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");
+          resolve(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`);
+          resolve(1);
+          return;
+        }
+        this.logger.info(`\u5C06\u521B\u5EFA ${num} \u7BC7\u7B14\u8BB0`);
+        resolve(num);
+      });
+    });
+  }
+  /**
+   * 提示用户输入笔记标题
+   */
+  async promptForTitle() {
+    const rl = createInterface2({
+      input: process.stdin,
+      output: process.stdout
+    });
+    return new Promise((resolve) => {
+      rl.question("\u8BF7\u8F93\u5165\u7B14\u8BB0\u6807\u9898: ", (answer) => {
+        rl.close();
+        resolve(answer.trim());
+      });
+    });
+  }
+};
+
+// commands/update-completed-count/UpdateCompletedCountCommand.ts
+import { execSync } from "child_process";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+var UpdateCompletedCountCommand = class extends BaseCommand {
+  constructor() {
+    super("update-completed-count");
+  }
+  async run() {
+    await this.updateCurrentRepo();
+  }
+  /**
+   * 更新当前知识库
+   */
+  async updateCurrentRepo() {
+    const startTime = Date.now();
+    try {
+      const configContent = readFileSync4(ROOT_CONFIG_PATH, "utf-8");
+      const config = JSON.parse(configContent);
+      this.logger.info("\u5F00\u59CB\u66F4\u65B0\u5B8C\u6210\u7B14\u8BB0\u6570\u91CF\u5386\u53F2\u8BB0\u5F55...");
+      const completedNotesCountHistory = await this.getCompletedNotesCountHistory(
+        config.root_item.created_at ?? Date.now()
+      );
+      config.root_item = {
+        ...config.root_item,
+        completed_notes_count: completedNotesCountHistory
+      };
+      writeFileSync3(ROOT_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+      const duration = Date.now() - startTime;
+      const monthKeys = Object.keys(completedNotesCountHistory);
+      const currentKey = monthKeys[monthKeys.length - 1];
+      const currentCount = completedNotesCountHistory[currentKey] || 0;
+      this.logger.success(
+        `\u5386\u53F2\u6570\u636E\u66F4\u65B0\u5B8C\u6210: \u5171 ${monthKeys.length} \u4E2A\u6708, \u5F53\u524D ${currentKey} \u6708\u5B8C\u6210 ${currentCount} \u7BC7\u7B14\u8BB0 (${duration}ms)`
+      );
+    } catch (error) {
+      this.logger.error(
+        `\u66F4\u65B0\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * 获取历史每个月的 completed_notes_count（最近12个月）
+   *
+   * 逻辑:
+   * 1. 计算最近12个月的范围（当前月份往前推11个月）
+   * 2. 遍历这12个月，从 Git 历史中读取 TOC.md（回退 README.md）
+   * 3. 解析获取完成笔记数量
+   * 4. 如果知识库创建时间在这12个月内，之前的月份补0
+   * 5. 返回对象 { '25.01': 0, '25.02': 1, ..., '25.12': 15 }
+   */
+  async getCompletedNotesCountHistory(createdAt) {
+    try {
+      const now = /* @__PURE__ */ new Date();
+      const currentYear = now.getFullYear();
+      const currentMonth = now.getMonth();
+      let firstYear = currentYear;
+      let firstMonth = currentMonth - 11;
+      if (firstMonth < 0) {
+        firstYear = currentYear - 1;
+        firstMonth = 12 + firstMonth;
+      }
+      const createdDate = new Date(createdAt);
+      const createdYear = createdDate.getFullYear();
+      const createdMonth = createdDate.getMonth();
+      const result = {};
+      let prevCount = 0;
+      for (let i = 0; i < 12; i++) {
+        const targetYear = firstYear + Math.floor((firstMonth + i) / 12);
+        const targetMonth = (firstMonth + i) % 12;
+        const yearShort = String(targetYear).slice(-2);
+        const monthStr = String(targetMonth + 1).padStart(2, "0");
+        const key = `${yearShort}.${monthStr}`;
+        const isBeforeCreation = targetYear < createdYear || targetYear === createdYear && targetMonth < createdMonth;
+        if (isBeforeCreation) {
+          result[key] = 0;
+          prevCount = 0;
+          this.logger.info(`\u2713 ${key}: 0 \u7BC7\uFF08\u65E9\u4E8E\u521B\u5EFA\u65F6\u95F4\uFF09`);
+        } else {
+          try {
+            const count = await this.getMonthCompletedCount(
+              targetYear,
+              targetMonth,
+              prevCount
+            );
+            result[key] = count;
+            prevCount = count;
+            this.logger.info(`\u2713 ${key}: ${count} \u7BC7`);
+          } catch (error) {
+            result[key] = prevCount;
+            this.logger.warn(`${key}: \u65E0\u6570\u636E\uFF0C\u4F7F\u7528 ${prevCount}\uFF08\u4E0A\u6708\u503C\uFF09`);
+          }
+        }
+      }
+      return result;
+    } catch (error) {
+      this.logger.error(
+        `\u83B7\u53D6\u5386\u53F2\u6570\u636E\u5931\u8D25: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {};
+    }
+  }
+  /**
+   * 获取指定月份的完成笔记数量
+   * @param year - 年份
+   * @param month - 月份 (0-11)
+   * @param fallbackCount - 回退值（如果该月没有数据）
+   * @returns 完成笔记数量
+   */
+  async getMonthCompletedCount(year, month, fallbackCount = 0) {
+    const lastDayOfMonth = new Date(year, month + 1, 0, 23, 59, 59);
+    const yearStr = lastDayOfMonth.getFullYear();
+    const monthStr = String(lastDayOfMonth.getMonth() + 1).padStart(2, "0");
+    const dayStr = String(lastDayOfMonth.getDate()).padStart(2, "0");
+    const untilDate = `${yearStr}-${monthStr}-${dayStr} 23:59:59 +0800`;
+    let commitHash = execSync(
+      `git log --until="${untilDate}" --format=%H -1 -- TOC.md`,
+      {
+        cwd: ROOT_DIR_PATH,
+        encoding: "utf-8"
+      }
+    ).trim();
+    let filePath = "TOC.md";
+    if (!commitHash) {
+      commitHash = execSync(
+        `git log --until="${untilDate}" --format=%H -1 -- README.md`,
+        {
+          cwd: ROOT_DIR_PATH,
+          encoding: "utf-8"
+        }
+      ).trim();
+      filePath = "README.md";
+    }
+    if (!commitHash) {
+      return fallbackCount;
+    }
+    let fileContent;
+    try {
+      fileContent = execSync(`git show ${commitHash}:${filePath}`, {
+        cwd: ROOT_DIR_PATH,
+        encoding: "utf-8"
+      });
+    } catch (error) {
+      return fallbackCount;
+    }
+    const { completedCount } = filePath === "TOC.md" ? parseTocCompletedNotes(fileContent) : parseReadmeCompletedNotes(fileContent);
+    return completedCount;
+  }
+};
+
+// commands/registry.ts
+var commandFactories = {
+  "build": () => new BuildCommand(),
+  "create-notes": () => new CreateNoteCommand(),
+  "dev": () => new DevCommand(),
+  "fix-timestamps": () => new FixTimestampsCommand(),
+  "init-sub-repo": () => new InitSubRepoCommand(),
+  "init-toc": () => new InitTocCommand(),
+  "help": () => new HelpCommand(),
+  "preview": () => new PreviewCommand(),
+  "pull": () => new PullCommand(),
+  "push": () => new PushCommand(),
+  "rename-note": () => new RenameNoteCommand(),
+  "update-completed-count": () => new UpdateCompletedCountCommand(),
+  "update-note-config": () => new UpdateNoteConfigCommand(),
+  "update": () => new UpdateCommand()
+};
+var commandCache = /* @__PURE__ */ new Map();
+function getCommand(name) {
+  if (!commandFactories[name]) return void 0;
+  if (!commandCache.has(name)) commandCache.set(name, commandFactories[name]());
+  return commandCache.get(name);
+}
+
+// index.ts
+(async () => {
+  try {
+    const args = parseArgs(process.argv.slice(2));
+    const commandName = Object.keys(args).find(
+      (key) => key !== "_" && args[key] === true
+    );
+    const command = commandName ? getCommand(commandName) : null;
+    if (!command) {
+      const logger2 = createLogger("command-not-found", {
+        timestamp: false
+      });
+      console.log(`
+${"-".repeat(66)}
+`);
+      if (commandName) {
+        logger2.warn(`\u672A\u627E\u5230\u547D\u4EE4\uFF1A${commandName}`);
+        logger2.info(`\u8BF7\u68C0\u67E5\u547D\u4EE4\u540D\u662F\u5426\u6B63\u786E\uFF01`);
+      } else {
+        logger2.warn(`\u672A\u68C0\u6D4B\u5230\u547D\u4EE4\u540D\uFF0C\u8BF7\u68C0\u67E5\u547D\u4EE4\u8F93\u5165\u662F\u5426\u6B63\u786E`);
+        logger2.info(`\u793A\u4F8B\uFF1A`);
+        logger2.info(`pnpm tn:<\u547D\u4EE4\u540D>`);
+        logger2.info(`npx tsx ./.vitepress/tnotes/index.ts --<\u547D\u4EE4\u540D>`);
+      }
+      console.log(`
+${"-".repeat(66)}
+`);
+      const helpCommand = getCommand(COMMAND_NAMES.HELP);
+      if (helpCommand) {
+        console.log("\n\u6B63\u5728\u6267\u884C pnpm tn:help \u6253\u5370\u5E2E\u52A9\u4FE1\u606F...\n");
+        await helpCommand.execute();
+      }
+      return;
+    }
+    if (commandName === COMMAND_NAMES.UPDATE) {
+      const cmd = command;
+      if (args.quiet) cmd.setQuiet(true);
+    } else if (commandName === COMMAND_NAMES.PUSH) {
+      const cmd = command;
+      if (args.force) cmd.setOptions({ force: true });
+    }
+    await command.execute();
+  } catch (error) {
+    handleError(error, true);
+  }
+})();