zengen 0.1.34 → 0.1.36

package/src/cli.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 
+import { config } from 'dotenv';
 import { Cli, Command, Option } from 'clipanion';
 import { ZenBuilder } from './builder';
 import { ZenConfig } from './types';
@@ -8,6 +9,9 @@ import * as fs from 'fs/promises';
 import * as fsSync from 'fs';
 import * as url from 'url';
 
+// 加载 .env 文件中的环境变量
+config();
+
 // 获取版本号 - 从 package.json 读取
 function getVersion(): string {
   try {
@@ -55,6 +59,10 @@ class BuildCommand extends BaseCommand {
   config = Option.String('-c,--config');
   baseUrl = Option.String('--base-url');
   clean = Option.Boolean('--clean');
+  ai = Option.Boolean('--ai', { description: 'Enable AI metadata extraction' });
+  lang = Option.Array('--lang', {
+    description: 'Target languages for translation (e.g., en-US, ja-JP)',
+  });
 
   static usage = Command.Usage({
     description: 'Build documentation site from Markdown files in current directory',
@@ -69,6 +77,8 @@ class BuildCommand extends BaseCommand {
         $ zengen build --watch --serve --port 8080
         $ zengen build --config zen.config.json
         $ zengen build --clean
+        $ zengen build --ai (requires OPENAI_API_KEY environment variable)
+        $ zengen build --lang en-US --lang ja-JP (translate to English and Japanese)
     `,
   });
 
@@ -81,6 +91,23 @@ class BuildCommand extends BaseCommand {
       const currentDir = process.cwd();
       const outDir = this.getOutDir();
 
+      // 处理 AI 配置：如果指定了 --ai 参数，启用 AI；否则使用配置中的设置
+      const aiConfig = {
+        ...config.ai,
+        enabled: this.ai ? true : config.ai?.enabled,
+      };
+
+      // 处理语言配置：命令行参数优先于配置文件
+      const targetLangs = this.lang && this.lang.length > 0 ? this.lang : config.i18n?.targetLangs;
+      const i18nConfig =
+        targetLangs && targetLangs.length > 0
+          ? {
+              ...config.i18n,
+              sourceLang: config.i18n?.sourceLang || 'zh-Hans', // 默认源语言为中文
+              targetLangs,
+            }
+          : undefined;
+
       // 合并命令行参数和配置
       const buildOptions = {
         srcDir: currentDir,
@@ -92,12 +119,20 @@ class BuildCommand extends BaseCommand {
         host: this.host,
         verbose: this.verbose,
         baseUrl: this.baseUrl || config.baseUrl,
+        langs: this.lang,
+      };
+
+      // 创建最终的配置，包含 AI 和 i18n 设置
+      const finalConfig = {
+        ...config,
+        ai: aiConfig.enabled ? aiConfig : undefined,
+        i18n: i18nConfig,
       };
 
-      const builder = new ZenBuilder(config);
+      const builder = new ZenBuilder(finalConfig);
 
       // 验证配置
-      const errors = builder.validateConfig(config);
+      const errors = builder.validateConfig(finalConfig);
       if (errors.length > 0) {
         this.context.stderr.write('❌ Configuration errors:\n');
         errors.forEach(error => this.context.stderr.write(`  - ${error}\n`));
@@ -121,7 +156,18 @@ class BuildCommand extends BaseCommand {
       if (this.watch) {
         await builder.watch(buildOptions);
       } else {
-        await builder.build(buildOptions);
+        // 如果指定了语言参数，使用多语言构建
+        if (this.lang && this.lang.length > 0) {
+          const multiLangOptions = {
+            ...buildOptions,
+            langs: this.lang,
+            useMetaData: true,
+            filterOrphans: true,
+          };
+          await builder.buildMultiLang(multiLangOptions);
+        } else {
+          await builder.build(buildOptions);
+        }
       }
 
       return 0;

package/src/gitignore.test.ts

@@ -35,10 +35,14 @@ describe('GitIgnoreProcessor', () => {
       assert.strictEqual(processor['baseDir'], '/test/dir');
     });
 
-    it('应该初始化空模式数组', () => {
+    it('应该初始化包含硬编码模式的数组', () => {
       const processor = new GitIgnoreProcessor('/test/dir');
       const patterns = processor.getPatterns();
-      assert.deepStrictEqual(patterns, []);
+      // 检查是否包含硬编码模式
+      assert.ok(patterns.includes('node_modules'));
+      assert.ok(patterns.includes('**/node_modules'));
+      assert.ok(patterns.includes('.git'));
+      assert.ok(patterns.includes('.zen'));
     });
   });
 
@@ -57,15 +61,28 @@ dist/
       await processor.loadFromFile('.gitignore');
 
       const patterns = processor.getPatterns();
-      assert.deepStrictEqual(patterns, ['**/node_modules', '*.log', '**/dist', '**/.DS_Store']);
+      // 应该包含硬编码模式和从.gitignore加载的模式
+      assert.ok(patterns.includes('node_modules')); // 硬编码
+      assert.ok(patterns.includes('**/node_modules')); // 从.gitignore加载
+      assert.ok(patterns.includes('*.log')); // 从.gitignore加载
+      assert.ok(patterns.includes('**/dist')); // 从.gitignore加载
+      assert.ok(patterns.includes('**/.DS_Store')); // 从.gitignore加载
+      assert.ok(patterns.includes('.git')); // 硬编码
+      assert.ok(patterns.includes('.zen')); // 硬编码
     });
 
-    it('当.gitignore文件不存在时应该使用空模式', async () => {
+    it('当.gitignore文件不存在时应该使用硬编码模式', async () => {
       const processor = new GitIgnoreProcessor(testDir);
       await processor.loadFromFile('non-existent-file');
 
       const patterns = processor.getPatterns();
-      assert.deepStrictEqual(patterns, []);
+      // 应该只包含硬编码模式
+      assert.ok(patterns.includes('node_modules'));
+      assert.ok(patterns.includes('**/node_modules'));
+      assert.ok(patterns.includes('.git'));
+      assert.ok(patterns.includes('.zen'));
+      // 不应该有用户定义的模式
+      assert.ok(!patterns.includes('*.log'));
     });
 
     it('应该跳过空行和注释', async () => {
@@ -83,7 +100,12 @@ node_modules/
       await processor.loadFromFile('.gitignore');
 
       const patterns = processor.getPatterns();
-      assert.deepStrictEqual(patterns, ['**/node_modules', '*.log']);
+      // 应该包含硬编码模式和从.gitignore加载的模式
+      assert.ok(patterns.includes('node_modules')); // 硬编码
+      assert.ok(patterns.includes('**/node_modules')); // 从.gitignore加载
+      assert.ok(patterns.includes('*.log')); // 从.gitignore加载
+      assert.ok(patterns.includes('.git')); // 硬编码
+      assert.ok(patterns.includes('.zen')); // 硬编码
     });
 
     it('应该跳过否定模式', async () => {
@@ -98,7 +120,12 @@ node_modules/
       await processor.loadFromFile('.gitignore');
 
       const patterns = processor.getPatterns();
-      assert.deepStrictEqual(patterns, ['**/node_modules', '*.log']);
+      // 应该包含硬编码模式和从.gitignore加载的模式（不包括否定模式）
+      assert.ok(patterns.includes('node_modules')); // 硬编码
+      assert.ok(patterns.includes('**/node_modules')); // 从.gitignore加载
+      assert.ok(patterns.includes('*.log')); // 从.gitignore加载
+      assert.ok(patterns.includes('.git')); // 硬编码
+      assert.ok(patterns.includes('.zen')); // 硬编码
     });
   });
 
@@ -112,7 +139,12 @@ dist/
       processor['parsePatterns'](content);
 
       const patterns = processor.getPatterns();
-      assert.deepStrictEqual(patterns, ['**/node_modules', '**/dist']);
+      // 应该包含硬编码模式和解析的模式
+      assert.ok(patterns.includes('node_modules')); // 硬编码
+      assert.ok(patterns.includes('**/node_modules')); // 从内容解析
+      assert.ok(patterns.includes('**/dist')); // 从内容解析
+      assert.ok(patterns.includes('.git')); // 硬编码
+      assert.ok(patterns.includes('.zen')); // 硬编码
     });
 
     it('应该正确处理文件扩展名模式', () => {
@@ -124,7 +156,12 @@ dist/
       processor['parsePatterns'](content);
 
       const patterns = processor.getPatterns();
-      assert.deepStrictEqual(patterns, ['*.log', '*.tmp']);
+      // 应该包含硬编码模式和解析的模式
+      assert.ok(patterns.includes('node_modules')); // 硬编码
+      assert.ok(patterns.includes('*.log')); // 从内容解析
+      assert.ok(patterns.includes('*.tmp')); // 从内容解析
+      assert.ok(patterns.includes('.git')); // 硬编码
+      assert.ok(patterns.includes('.zen')); // 硬编码
     });
 
     it('应该处理以/开头的模式', () => {
@@ -136,7 +173,11 @@ dist/
       processor['parsePatterns'](content);
 
       const patterns = processor.getPatterns();
-      assert.deepStrictEqual(patterns, ['node_modules', 'dist']);
+      // 应该包含硬编码模式和解析的模式
+      assert.ok(patterns.includes('node_modules')); // 硬编码
+      assert.ok(patterns.includes('dist')); // 从内容解析
+      assert.ok(patterns.includes('.git')); // 硬编码
+      assert.ok(patterns.includes('.zen')); // 硬编码
     });
 
     it('应该处理包含通配符的模式', () => {
@@ -148,7 +189,12 @@ dist/
       processor['parsePatterns'](content);
 
       const patterns = processor.getPatterns();
-      assert.deepStrictEqual(patterns, ['**/node_modules', '**/.vscode']);
+      // 应该包含硬编码模式和解析的模式
+      assert.ok(patterns.includes('node_modules')); // 硬编码
+      assert.ok(patterns.includes('**/node_modules')); // 从内容解析
+      assert.ok(patterns.includes('**/.vscode')); // 从内容解析
+      assert.ok(patterns.includes('.git')); // 硬编码
+      assert.ok(patterns.includes('.zen')); // 硬编码
     });
   });
 
@@ -218,21 +264,35 @@ dist/
       const processor = new GitIgnoreProcessor(testDir);
 
       processor.addPattern('custom-pattern');
-      assert.deepStrictEqual(processor.getPatterns(), ['custom-pattern']);
+      const patterns = processor.getPatterns();
+      // 应该包含硬编码模式和自定义模式
+      assert.ok(patterns.includes('node_modules')); // 硬编码
+      assert.ok(patterns.includes('custom-pattern')); // 自定义
 
       processor.addPattern('another-pattern');
-      assert.deepStrictEqual(processor.getPatterns(), ['custom-pattern', 'another-pattern']);
+      const updatedPatterns = processor.getPatterns();
+      assert.ok(updatedPatterns.includes('node_modules')); // 硬编码
+      assert.ok(updatedPatterns.includes('custom-pattern')); // 自定义
+      assert.ok(updatedPatterns.includes('another-pattern')); // 自定义
     });
 
-    it('应该能够清除所有模式', () => {
+    it('应该能够清除所有用户模式（但保留硬编码模式）', () => {
       const processor = new GitIgnoreProcessor(testDir);
 
       processor.addPattern('pattern1');
       processor.addPattern('pattern2');
-      assert.strictEqual(processor.getPatterns().length, 2);
+      // 总模式数 = 硬编码模式数 + 用户模式数
+      const totalPatterns = processor.getPatterns().length;
+      assert.ok(totalPatterns >= 2); // 至少包含硬编码模式
 
       processor.clearPatterns();
-      assert.deepStrictEqual(processor.getPatterns(), []);
+      const patternsAfterClear = processor.getPatterns();
+      // 清除后应该只包含硬编码模式
+      assert.ok(patternsAfterClear.includes('node_modules'));
+      assert.ok(patternsAfterClear.includes('.git'));
+      assert.ok(patternsAfterClear.includes('.zen'));
+      assert.ok(!patternsAfterClear.includes('pattern1'));
+      assert.ok(!patternsAfterClear.includes('pattern2'));
     });
   });
 
@@ -247,7 +307,12 @@ node_modules/
       const processor = await createGitIgnoreProcessor(testDir);
       const patterns = processor.getPatterns();
 
-      assert.deepStrictEqual(patterns, ['**/node_modules', '*.log']);
+      // 应该包含硬编码模式和从.gitignore加载的模式
+      assert.ok(patterns.includes('node_modules')); // 硬编码
+      assert.ok(patterns.includes('**/node_modules')); // 从.gitignore加载
+      assert.ok(patterns.includes('*.log')); // 从.gitignore加载
+      assert.ok(patterns.includes('.git')); // 硬编码
+      assert.ok(patterns.includes('.zen')); // 硬编码
     });
   });
 });

package/src/gitignore.ts

@@ -10,6 +10,19 @@ export class GitIgnoreProcessor {
   private patterns: string[] = [];
   private baseDir: string;
 
+  // 始终忽略的硬编码模式列表
+  private readonly hardcodedPatterns: string[] = [
+    'node_modules', // Node.js 依赖目录
+    '**/node_modules', // 任意深度的 node_modules
+    '**/node_modules/**', // node_modules 中的所有内容
+    '.git', // Git 目录
+    '**/.git', // 任意深度的 .git 目录
+    '**/.git/**', // .git 目录中的所有内容
+    '.zen', // ZEN 构建输出目录
+    '**/.zen', // 任意深度的 .zen 目录
+    '**/.zen/**', // .zen 目录中的所有内容
+  ];
+
   constructor(baseDir: string) {
     this.baseDir = baseDir;
   }
@@ -90,7 +103,14 @@ export class GitIgnoreProcessor {
     // 标准化路径分隔符为 /
     const normalizedPath = relativePath.replace(/\\/g, '/');
 
-    // 检查每个模式
+    // 首先检查硬编码模式（始终忽略）
+    for (const pattern of this.hardcodedPatterns) {
+      if (minimatch(normalizedPath, pattern, { dot: true })) {
+        return true;
+      }
+    }
+
+    // 然后检查用户定义的 .gitignore 模式
     for (const pattern of this.patterns) {
       // 首先尝试直接匹配
       if (minimatch(normalizedPath, pattern, { dot: true })) {
@@ -142,10 +162,10 @@ export class GitIgnoreProcessor {
   }
 
   /**
-   * 获取所有忽略模式
+   * 获取所有忽略模式（包括硬编码模式）
    */
   getPatterns(): string[] {
-    return [...this.patterns];
+    return [...this.hardcodedPatterns, ...this.patterns];
   }
 
   /**

package/src/markdown.ts

@@ -1,6 +1,6 @@
 import { marked } from 'marked';
 import hljs from 'highlight.js';
-import { FileInfo, MarkdownProcessor } from './types';
+import { FileInfo, MarkdownProcessor, ScannedFile } from './types';
 import * as fs from 'fs/promises';
 import * as path from 'path';
 import { GitIgnoreProcessor } from './gitignore';
@@ -123,8 +123,7 @@ export class MarkdownConverter {
     const name = path.basename(filePath, ext);
 
     const fileInfo: FileInfo = {
-      path: filePath,
-      relativePath,
+      path: relativePath,
       name,
       ext,
       content,
@@ -135,14 +134,15 @@ export class MarkdownConverter {
 
   /**
    * 从目录读取所有 Markdown 文件并转换
+   * 保持向后兼容，但内部使用扫描逻辑
    */
   async convertDirectory(dirPath: string): Promise<FileInfo[]> {
-    const files: FileInfo[] = [];
-
-    // 创建 GitIgnoreProcessor 并加载 .gitignore 文件
+    // 使用扫描逻辑获取文件列表
     const gitignoreProcessor = new GitIgnoreProcessor(dirPath);
     await gitignoreProcessor.loadFromFile();
 
+    const scannedFiles: ScannedFile[] = [];
+
     async function scanDirectory(currentPath: string) {
       const entries = await fs.readdir(currentPath, { withFileTypes: true });
 
@@ -162,23 +162,51 @@ export class MarkdownConverter {
         if (entry.isDirectory()) {
           await scanDirectory(fullPath);
         } else if (entry.isFile() && entry.name.endsWith('.md')) {
-          const content = await fs.readFile(fullPath, 'utf-8');
           const relativePath = path.relative(dirPath, fullPath);
           const ext = path.extname(entry.name);
           const name = path.basename(entry.name, ext);
 
-          files.push({
-            path: fullPath,
-            relativePath,
+          scannedFiles.push({
+            path: relativePath,
             name,
             ext,
-            content,
           });
         }
       }
     }
 
     await scanDirectory(dirPath);
+
+    // 使用新的方法转换扫描的文件
+    return this.convertScannedFiles(scannedFiles, dirPath);
+  }
+
+  /**
+   * 从扫描的文件列表读取内容并转换
+   */
+  async convertScannedFiles(
+    scannedFiles: ScannedFile[],
+    baseDir: string = ''
+  ): Promise<FileInfo[]> {
+    const files: FileInfo[] = [];
+
+    for (const scannedFile of scannedFiles) {
+      try {
+        // 构建绝对路径
+        const absolutePath = baseDir ? path.join(baseDir, scannedFile.path) : scannedFile.path;
+        const content = await fs.readFile(absolutePath, 'utf-8');
+        files.push({
+          path: scannedFile.path,
+          name: scannedFile.name,
+          ext: scannedFile.ext,
+          content,
+          hash: scannedFile.hash, // 复制 hash 字段
+        });
+      } catch (error) {
+        console.warn(`⚠️ Failed to read file ${scannedFile.path}:`, error);
+      }
+    }
+
     return this.convertFiles(files);
   }
 }

package/src/navigation.ts

@@ -20,7 +20,7 @@ export class NavigationGenerator {
    */
   generate(files: FileInfo[]): NavigationItem[] {
     // 按路径排序
-    const sortedFiles = [...files].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+    const sortedFiles = [...files].sort((a, b) => a.path.localeCompare(b.path));
 
     // 构建树形结构
     const root: NavigationItem[] = [];
@@ -36,7 +36,7 @@ export class NavigationGenerator {
    * 将文件添加到导航树中
    */
   private addFileToNavigation(navigation: NavigationItem[], file: FileInfo): void {
-    const parts = file.relativePath.split('/');
+    const parts = file.path.split('/');
     let currentLevel = navigation;
 
     for (let i = 0; i < parts.length; i++) {
@@ -55,7 +55,7 @@ export class NavigationGenerator {
 
       // 生成路径
       const rawPath = isMarkdownFile
-        ? `/${file.relativePath.replace(/\.md$/, '.html')}`
+        ? `/${file.path.replace(/\.md$/, '.html')}`
         : `/${parts.slice(0, i + 1).join('/')}`;
       const itemPath = this.generatePath(rawPath);
 
@@ -137,7 +137,7 @@ export class NavigationGenerator {
     return files
       .map(file => {
         const title = file.metadata?.title || this.formatTitle(file.name); // 优先使用提取的标题
-        const rawPath = `/${file.relativePath.replace(/\.md$/, '.html')}`;
+        const rawPath = `/${file.path.replace(/\.md$/, '.html')}`;
         const itemPath = this.generatePath(rawPath);
 
         return {
@@ -209,7 +209,7 @@ export class NavigationGenerator {
     const effectiveBaseUrl = baseUrl || this.baseUrl || 'https://example.com';
     const urls = files
       .map(file => {
-        const path = `/${file.relativePath.replace(/\.md$/, '.html')}`;
+        const path = `/${file.path.replace(/\.md$/, '.html')}`;
         const lastmod = new Date().toISOString().split('T')[0];
 
         return `  <url>

package/src/scanner.ts

@@ -0,0 +1,180 @@
+import { ScannedFile, ZenConfig } from './types';
+import { GitIgnoreProcessor } from './gitignore';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as minimatch from 'minimatch';
+import * as crypto from 'crypto';
+
+export class Scanner {
+  private config: ZenConfig;
+
+  constructor(config: ZenConfig = {}) {
+    this.config = config;
+  }
+
+  /**
+   * 计算文件内容的 sha256 hash
+   */
+  private async calculateFileHash(filePath: string): Promise<string> {
+    try {
+      const content = await fs.readFile(filePath, 'utf-8');
+      return crypto.createHash('sha256').update(content).digest('hex');
+    } catch (error) {
+      console.warn(`⚠️ Failed to calculate hash for ${filePath}:`, error);
+      return '';
+    }
+  }
+
+  /**
+   * 扫描目录并生成文件列表
+   */
+  async scanDirectory(dirPath: string): Promise<ScannedFile[]> {
+    const files: ScannedFile[] = [];
+
+    // 创建 GitIgnoreProcessor 并加载 .gitignore 文件
+    const gitignoreProcessor = new GitIgnoreProcessor(dirPath);
+    await gitignoreProcessor.loadFromFile();
+
+    // 获取 include/exclude 模式
+    const includePattern = this.config.includePattern || '**/*.md';
+    const excludePattern = this.config.excludePattern;
+
+    const scanDirectory = async (currentPath: string) => {
+      const entries = await fs.readdir(currentPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+
+        // 检查是否应该被 .gitignore 忽略
+        if (gitignoreProcessor.shouldIgnore(fullPath)) {
+          continue;
+        }
+
+        // 忽略 .zen 目录（保持向后兼容）
+        if (entry.name === '.zen') {
+          continue;
+        }
+
+        if (entry.isDirectory()) {
+          await scanDirectory(fullPath);
+        } else if (entry.isFile()) {
+          const relativePath = path.relative(dirPath, fullPath);
+
+          // 应用 include 模式
+          if (!minimatch.match([relativePath], includePattern).length) {
+            continue;
+          }
+
+          // 应用 exclude 模式
+          if (excludePattern && minimatch.match([relativePath], excludePattern).length > 0) {
+            continue;
+          }
+
+          const ext = path.extname(entry.name);
+          const name = path.basename(entry.name, ext);
+          const hash = await this.calculateFileHash(fullPath);
+
+          files.push({
+            path: relativePath, // 只保存相对路径
+            name,
+            ext,
+            hash,
+          });
+        }
+      }
+    };
+
+    await scanDirectory(dirPath);
+    return files;
+  }
+
+  /**
+   * 保存扫描结果到文件
+   */
+  async saveScanResult(files: ScannedFile[], outputPath: string): Promise<void> {
+    // 确保输出目录存在
+    await fs.mkdir(path.dirname(outputPath), { recursive: true });
+
+    // 将扫描结果保存为 JSON
+    const scanResult = {
+      timestamp: new Date().toISOString(),
+      files,
+    };
+
+    await fs.writeFile(outputPath, JSON.stringify(scanResult, null, 2), 'utf-8');
+  }
+
+  /**
+   * 从文件加载扫描结果
+   */
+  async loadScanResult(inputPath: string): Promise<ScannedFile[]> {
+    try {
+      const content = await fs.readFile(inputPath, 'utf-8');
+      const scanResult = JSON.parse(content);
+      return scanResult.files || [];
+    } catch (error) {
+      console.warn(`⚠️ Failed to load scan result from ${inputPath}:`, error);
+      return [];
+    }
+  }
+
+  /**
+   * 检查扫描结果是否过期
+   */
+  async isScanResultOutdated(scanResultPath: string, dirPath: string): Promise<boolean> {
+    try {
+      // 检查扫描结果文件是否存在
+      await fs.access(scanResultPath);
+
+      // 读取扫描结果的时间戳
+      const content = await fs.readFile(scanResultPath, 'utf-8');
+      const scanResult = JSON.parse(content);
+      const scanTime = new Date(scanResult.timestamp).getTime();
+
+      // 检查源目录中是否有文件比扫描时间更新
+      const gitignoreProcessor = new GitIgnoreProcessor(dirPath);
+      await gitignoreProcessor.loadFromFile();
+
+      let isOutdated = false;
+
+      async function checkDirectory(currentPath: string) {
+        const entries = await fs.readdir(currentPath, { withFileTypes: true });
+
+        for (const entry of entries) {
+          const fullPath = path.join(currentPath, entry.name);
+
+          // 检查是否应该被 .gitignore 忽略
+          if (gitignoreProcessor.shouldIgnore(fullPath)) {
+            continue;
+          }
+
+          // 忽略 .zen 目录
+          if (entry.name === '.zen') {
+            continue;
+          }
+
+          if (entry.isDirectory()) {
+            await checkDirectory(fullPath);
+          } else if (entry.isFile()) {
+            // 检查文件修改时间
+            const stats = await fs.stat(fullPath);
+            if (stats.mtime.getTime() > scanTime) {
+              isOutdated = true;
+              return; // 提前退出
+            }
+          }
+
+          if (isOutdated) {
+            break;
+          }
+        }
+      }
+
+      await checkDirectory(dirPath);
+      return isOutdated;
+    } catch (error) {
+      // 如果扫描结果文件不存在或读取失败，视为过期
+      return true;
+    }
+  }
+}