zengen 0.1.36 → 0.2.0

package/src/markdown.ts

@@ -1,212 +0,0 @@
-import { marked } from 'marked';
-import hljs from 'highlight.js';
-import { FileInfo, MarkdownProcessor, ScannedFile } from './types';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { GitIgnoreProcessor } from './gitignore';
-
-// 配置 marked 使用 highlight.js 进行代码高亮
-marked.setOptions({
-  highlight: function (code: string, lang: string) {
-    if (lang && hljs.getLanguage(lang)) {
-      try {
-        return hljs.highlight(code, { language: lang }).value;
-      } catch (err) {
-        console.warn(`Failed to highlight code with language ${lang}:`, err);
-      }
-    }
-    return hljs.highlightAuto(code).value;
-  },
-  pedantic: false,
-  gfm: true,
-  breaks: false,
-  sanitize: false,
-  smartLists: true,
-  smartypants: false,
-  xhtml: false,
-} as any);
-
-export class MarkdownConverter {
-  private processors: MarkdownProcessor[] = [];
-
-  constructor(processors: MarkdownProcessor[] = []) {
-    this.processors = processors;
-  }
-
-  /**
-   * 添加处理器
-   */
-  addProcessor(processor: MarkdownProcessor): void {
-    this.processors.push(processor);
-  }
-
-  /**
-   * 从内容中提取标题
-   */
-  private extractTitle(content: string): string {
-    // 查找第一个一级标题
-    const h1Match = content.match(/^#\s+(.+)$/m);
-    if (h1Match) {
-      return h1Match[1].trim();
-    }
-
-    // 如果没有一级标题，查找第一个二级标题
-    const h2Match = content.match(/^##\s+(.+)$/m);
-    if (h2Match) {
-      return h2Match[1].trim();
-    }
-
-    return 'Untitled';
-  }
-
-  /**
-   * 转换 Markdown 文件
-   */
-  async convert(fileInfo: FileInfo): Promise<FileInfo> {
-    let content = fileInfo.content;
-
-    // 应用前置处理器
-    for (const processor of this.processors) {
-      if (processor.beforeParse) {
-        content = await processor.beforeParse(content, fileInfo);
-      }
-    }
-
-    // 转换 Markdown 为 HTML
-    let html = marked.parse(content) as string;
-
-    // 应用后置处理器
-    for (const processor of this.processors) {
-      if (processor.afterParse) {
-        html = await processor.afterParse(html, fileInfo);
-      }
-    }
-
-    // 提取标题
-    const title = this.extractTitle(content);
-
-    return {
-      ...fileInfo,
-      content,
-      html,
-      metadata: { title }, // 只保留标题作为 metadata
-    };
-  }
-
-  /**
-   * 批量转换文件
-   */
-  async convertFiles(files: FileInfo[]): Promise<FileInfo[]> {
-    const results: FileInfo[] = [];
-
-    for (const file of files) {
-      try {
-        const result = await this.convert(file);
-        results.push(result);
-      } catch (error) {
-        console.error(`Failed to convert file ${file.path}:`, error);
-        // 即使转换失败，也保留原始文件信息
-        results.push(file);
-      }
-    }
-
-    return results;
-  }
-
-  /**
-   * 从文件路径读取并转换
-   */
-  async convertFromPath(filePath: string, baseDir: string = ''): Promise<FileInfo> {
-    const content = await fs.readFile(filePath, 'utf-8');
-    const relativePath = baseDir ? path.relative(baseDir, filePath) : filePath;
-    const ext = path.extname(filePath);
-    const name = path.basename(filePath, ext);
-
-    const fileInfo: FileInfo = {
-      path: relativePath,
-      name,
-      ext,
-      content,
-    };
-
-    return this.convert(fileInfo);
-  }
-
-  /**
-   * 从目录读取所有 Markdown 文件并转换
-   * 保持向后兼容，但内部使用扫描逻辑
-   */
-  async convertDirectory(dirPath: string): Promise<FileInfo[]> {
-    // 使用扫描逻辑获取文件列表
-    const gitignoreProcessor = new GitIgnoreProcessor(dirPath);
-    await gitignoreProcessor.loadFromFile();
-
-    const scannedFiles: ScannedFile[] = [];
-
-    async function scanDirectory(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() && entry.name.endsWith('.md')) {
-          const relativePath = path.relative(dirPath, fullPath);
-          const ext = path.extname(entry.name);
-          const name = path.basename(entry.name, ext);
-
-          scannedFiles.push({
-            path: relativePath,
-            name,
-            ext,
-          });
-        }
-      }
-    }
-
-    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

@@ -1,237 +0,0 @@
-import { NavigationItem, FileInfo } from './types';
-import * as path from 'path';
-
-export class NavigationGenerator {
-  private baseUrl: string;
-
-  constructor(baseUrl: string = '') {
-    this.baseUrl = baseUrl;
-  }
-
-  /**
-   * 更新 baseUrl
-   */
-  setBaseUrl(baseUrl: string): void {
-    this.baseUrl = baseUrl;
-  }
-
-  /**
-   * 从文件信息生成导航结构
-   */
-  generate(files: FileInfo[]): NavigationItem[] {
-    // 按路径排序
-    const sortedFiles = [...files].sort((a, b) => a.path.localeCompare(b.path));
-
-    // 构建树形结构
-    const root: NavigationItem[] = [];
-
-    for (const file of sortedFiles) {
-      this.addFileToNavigation(root, file);
-    }
-
-    return root;
-  }
-
-  /**
-   * 将文件添加到导航树中
-   */
-  private addFileToNavigation(navigation: NavigationItem[], file: FileInfo): void {
-    const parts = file.path.split('/');
-    let currentLevel = navigation;
-
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      const isLastPart = i === parts.length - 1;
-      const isMarkdownFile = part.endsWith('.md');
-
-      // 如果是 Markdown 文件，移除扩展名
-      const displayName = isMarkdownFile ? part.replace(/\.md$/, '') : part;
-
-      // 生成标题（对于 Markdown 文件优先使用提取的标题）
-      const title =
-        isMarkdownFile && file.metadata?.title
-          ? file.metadata.title
-          : this.formatTitle(displayName);
-
-      // 生成路径
-      const rawPath = isMarkdownFile
-        ? `/${file.path.replace(/\.md$/, '.html')}`
-        : `/${parts.slice(0, i + 1).join('/')}`;
-      const itemPath = this.generatePath(rawPath);
-
-      if (isLastPart) {
-        // 添加文件节点
-        currentLevel.push({
-          title,
-          path: itemPath,
-        });
-      } else {
-        // 查找或创建目录节点
-        // 首先尝试通过路径查找（最准确）
-        let dirItem = currentLevel.find(item => item.path === itemPath);
-
-        // 如果没找到，尝试通过格式化后的标题查找
-        if (!dirItem) {
-          const formattedTitle = this.formatTitle(displayName);
-          dirItem = currentLevel.find(
-            item => item.title === formattedTitle && item.children !== undefined
-          );
-        }
-
-        if (!dirItem) {
-          dirItem = {
-            title: this.formatTitle(displayName),
-            path: itemPath,
-            children: [],
-          };
-          currentLevel.push(dirItem);
-        }
-
-        // 确保 children 存在
-        if (!dirItem.children) {
-          dirItem.children = [];
-        }
-
-        // 进入下一层
-        currentLevel = dirItem.children;
-      }
-    }
-  }
-
-  /**
-   * 生成带 baseUrl 的路径
-   */
-  private generatePath(path: string): string {
-    if (!this.baseUrl) {
-      return path;
-    }
-
-    // 确保 baseUrl 不以斜杠结尾，路径以斜杠开头
-    const cleanBaseUrl = this.baseUrl.replace(/\/$/, '');
-    const cleanPath = path.startsWith('/') ? path : `/${path}`;
-
-    return `${cleanBaseUrl}${cleanPath}`;
-  }
-
-  /**
-   * 格式化标题（将连字符/下划线转换为空格并首字母大写）
-   */
-  private formatTitle(name: string): string {
-    // 移除扩展名
-    const baseName = name.replace(/\.[^/.]+$/, '');
-
-    // 将连字符、下划线、点替换为空格
-    const withSpaces = baseName.replace(/[-_.]/g, ' ');
-
-    // 首字母大写每个单词
-    return withSpaces
-      .split(' ')
-      .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
-      .join(' ');
-  }
-
-  /**
-   * 生成扁平化导航（所有页面在同一层级）
-   */
-  generateFlat(files: FileInfo[]): NavigationItem[] {
-    return files
-      .map(file => {
-        const title = file.metadata?.title || this.formatTitle(file.name); // 优先使用提取的标题
-        const rawPath = `/${file.path.replace(/\.md$/, '.html')}`;
-        const itemPath = this.generatePath(rawPath);
-
-        return {
-          title,
-          path: itemPath,
-        };
-      })
-      .sort((a, b) => a.title.localeCompare(b.title));
-  }
-
-  /**
-   * 生成面包屑导航
-   */
-  generateBreadcrumbs(filePath: string, navigation: NavigationItem[]): NavigationItem[] {
-    const parts = filePath.split('/').filter(part => part);
-    const breadcrumbs: NavigationItem[] = [];
-    let currentNav = navigation;
-
-    for (let i = 0; i < parts.length; i++) {
-      const part = parts[i];
-      const isLast = i === parts.length - 1;
-      const searchPath = `/${parts.slice(0, i + 1).join('/')}`;
-
-      // 在当前层级查找匹配的导航项
-      const foundItem = this.findNavigationItem(currentNav, searchPath);
-
-      if (foundItem) {
-        breadcrumbs.push({
-          title: foundItem.title,
-          path: foundItem.path,
-        });
-
-        if (foundItem.children && !isLast) {
-          currentNav = foundItem.children;
-        }
-      }
-    }
-
-    return breadcrumbs;
-  }
-
-  /**
-   * 在导航树中查找项目
-   */
-  private findNavigationItem(
-    navigation: NavigationItem[],
-    searchPath: string
-  ): NavigationItem | null {
-    for (const item of navigation) {
-      if (item.path === searchPath) {
-        return item;
-      }
-
-      if (item.children) {
-        const found = this.findNavigationItem(item.children, searchPath);
-        if (found) {
-          return found;
-        }
-      }
-    }
-
-    return null;
-  }
-
-  /**
-   * 生成站点地图 XML
-   */
-  generateSitemap(files: FileInfo[], baseUrl?: string): string {
-    const effectiveBaseUrl = baseUrl || this.baseUrl || 'https://example.com';
-    const urls = files
-      .map(file => {
-        const path = `/${file.path.replace(/\.md$/, '.html')}`;
-        const lastmod = new Date().toISOString().split('T')[0];
-
-        return `  <url>
-    <loc>${effectiveBaseUrl}${path}</loc>
-    <lastmod>${lastmod}</lastmod>
-    <changefreq>weekly</changefreq>
-    <priority>0.8</priority>
-  </url>`;
-      })
-      .join('\n');
-
-    return `<?xml version="1.0" encoding="UTF-8"?>
-<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
-${urls}
-</urlset>`;
-  }
-
-  /**
-   * 生成 JSON 格式的导航数据（用于前端动态加载）
-   */
-  generateJsonNavigation(files: FileInfo[]): string {
-    const navigation = this.generate(files);
-    return JSON.stringify(navigation, null, 2);
-  }
-}

package/src/scanner.ts

@@ -1,180 +0,0 @@
-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;
-    }
-  }
-}