zengen 0.1.35 → 0.2.0

package/src/gitignore.ts

@@ -1,173 +0,0 @@
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import { minimatch } from 'minimatch';
-
-/**
- * GitIgnore 处理器
- * 用于读取和解析 .gitignore 文件，并提供文件过滤功能
- */
-export class GitIgnoreProcessor {
-  private patterns: string[] = [];
-  private baseDir: string;
-
-  constructor(baseDir: string) {
-    this.baseDir = baseDir;
-  }
-
-  /**
-   * 从 .gitignore 文件加载模式
-   */
-  async loadFromFile(gitignorePath: string = '.gitignore'): Promise<void> {
-    try {
-      const fullPath = path.join(this.baseDir, gitignorePath);
-      const content = await fs.readFile(fullPath, 'utf-8');
-      this.parsePatterns(content);
-    } catch (error) {
-      // 如果 .gitignore 文件不存在，使用空模式
-      console.debug(`No .gitignore file found at ${gitignorePath}, using empty patterns`);
-    }
-  }
-
-  /**
-   * 解析 .gitignore 内容为模式数组
-   */
-  private parsePatterns(content: string): void {
-    const lines = content.split('\n');
-    this.patterns = [];
-
-    for (let line of lines) {
-      line = line.trim();
-
-      // 跳过空行和注释
-      if (!line || line.startsWith('#')) {
-        continue;
-      }
-
-      // 处理否定模式（以 ! 开头）
-      if (line.startsWith('!')) {
-        // 暂时不支持否定模式，可以后续扩展
-        continue;
-      }
-
-      // 标准化模式
-      let pattern = line;
-
-      // 如果模式以 / 结尾，表示目录
-      if (pattern.endsWith('/')) {
-        pattern = pattern.slice(0, -1);
-      }
-
-      // 如果模式不以 * 开头，添加 **/ 前缀以匹配任意子目录
-      if (!pattern.includes('*') && !pattern.startsWith('/')) {
-        pattern = `**/${pattern}`;
-      }
-
-      // 如果模式以 / 开头，从根目录开始匹配
-      if (pattern.startsWith('/')) {
-        pattern = pattern.slice(1);
-      }
-
-      this.patterns.push(pattern);
-    }
-
-    console.debug(`Loaded ${this.patterns.length} patterns from .gitignore`);
-  }
-
-  /**
-   * 检查文件是否应该被忽略
-   * @param filePath 文件的绝对路径
-   * @returns 如果应该被忽略返回 true
-   */
-  shouldIgnore(filePath: string): boolean {
-    // 获取相对于 baseDir 的相对路径
-    const relativePath = path.relative(this.baseDir, filePath);
-
-    // 如果文件在 baseDir 之外，不应用规则
-    if (relativePath.startsWith('..')) {
-      return false;
-    }
-
-    // 标准化路径分隔符为 /
-    const normalizedPath = relativePath.replace(/\\/g, '/');
-
-    // 检查每个模式
-    for (const pattern of this.patterns) {
-      // 首先尝试直接匹配
-      if (minimatch(normalizedPath, pattern, { dot: true })) {
-        return true;
-      }
-
-      // 对于目录模式，检查文件是否在该目录下
-      // 目录模式通常以 / 结尾或没有扩展名
-      if (pattern.endsWith('/') || (!pattern.includes('.') && !pattern.includes('*'))) {
-        const dirPattern = pattern.endsWith('/') ? pattern.slice(0, -1) : pattern;
-
-        // 检查文件是否在目录中
-        if (normalizedPath.startsWith(dirPattern + '/')) {
-          return true;
-        }
-
-        // 检查是否就是目录本身
-        if (normalizedPath === dirPattern) {
-          return true;
-        }
-      }
-
-      // 对于包含通配符的目录模式（如 **/node_modules, **/.vscode）
-      // 提取目录名并检查
-      if (pattern.includes('*')) {
-        // 尝试提取目录名（最后一个非通配符部分）
-        const parts = pattern.split('/');
-        const lastPart = parts[parts.length - 1];
-
-        // 如果最后一部分不包含通配符，可能是目录名
-        // 注意：.vscode 以点开头，但仍然是目录名
-        if (!lastPart.includes('*')) {
-          // 检查是否是文件扩展名（包含点但不是以点开头的目录）
-          const hasFileExtension = lastPart.includes('.') && !lastPart.startsWith('.');
-
-          if (!hasFileExtension) {
-            if (normalizedPath.startsWith(lastPart + '/')) {
-              return true;
-            }
-            if (normalizedPath === lastPart) {
-              return true;
-            }
-          }
-        }
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * 获取所有忽略模式
-   */
-  getPatterns(): string[] {
-    return [...this.patterns];
-  }
-
-  /**
-   * 添加自定义忽略模式
-   */
-  addPattern(pattern: string): void {
-    this.patterns.push(pattern);
-  }
-
-  /**
-   * 清除所有模式
-   */
-  clearPatterns(): void {
-    this.patterns = [];
-  }
-}
-
-/**
- * 创建 GitIgnoreProcessor 实例并加载 .gitignore 文件
- */
-export async function createGitIgnoreProcessor(baseDir: string): Promise<GitIgnoreProcessor> {
-  const processor = new GitIgnoreProcessor(baseDir);
-  await processor.loadFromFile();
-  return processor;
-}

package/src/markdown.ts

@@ -1,184 +0,0 @@
-import { marked } from 'marked';
-import hljs from 'highlight.js';
-import { FileInfo, MarkdownProcessor } 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: filePath,
-      relativePath,
-      name,
-      ext,
-      content,
-    };
-
-    return this.convert(fileInfo);
-  }
-
-  /**
-   * 从目录读取所有 Markdown 文件并转换
-   */
-  async convertDirectory(dirPath: string): Promise<FileInfo[]> {
-    const files: FileInfo[] = [];
-
-    // 创建 GitIgnoreProcessor 并加载 .gitignore 文件
-    const gitignoreProcessor = new GitIgnoreProcessor(dirPath);
-    await gitignoreProcessor.loadFromFile();
-
-    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 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,
-            name,
-            ext,
-            content,
-          });
-        }
-      }
-    }
-
-    await scanDirectory(dirPath);
-    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.relativePath.localeCompare(b.relativePath));
-
-    // 构建树形结构
-    const root: NavigationItem[] = [];
-
-    for (const file of sortedFiles) {
-      this.addFileToNavigation(root, file);
-    }
-
-    return root;
-  }
-
-  /**
-   * 将文件添加到导航树中
-   */
-  private addFileToNavigation(navigation: NavigationItem[], file: FileInfo): void {
-    const parts = file.relativePath.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.relativePath.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.relativePath.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.relativePath.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);
-  }
-}