zengen 0.1.36 → 0.2.1

package/src/ai-processor.ts

@@ -1,243 +0,0 @@
-import { MarkdownProcessor, FileInfo, ZenConfig } from './types';
-import { AIService } from './ai-service';
-import { AIClient } from './ai-client';
-
-/**
- * AI 处理器 - 集成到 Markdown 处理流程中
- */
-export class AIProcessor implements MarkdownProcessor {
-  private aiService: AIService;
-  private aiClient: AIClient;
-  private enabled: boolean;
-
-  constructor(config: ZenConfig = {}) {
-    // 从配置和环境变量初始化 AI 服务
-    const aiConfig = {
-      enabled: config.ai?.enabled ?? true,
-      model: config.ai?.model,
-      temperature: config.ai?.temperature,
-      maxTokens: config.ai?.maxTokens,
-    };
-
-    this.aiService = new AIService(aiConfig);
-    this.aiClient = new AIClient(this.aiService);
-    this.enabled = this.aiService.isEnabled();
-
-    if (this.enabled) {
-      console.log('🤖 AI processor initialized and enabled');
-      console.log(`   Model: ${this.aiService.getConfig().model}`);
-      console.log(`   Base URL: ${this.aiService.getConfig().baseUrl}`);
-    } else {
-      console.log('⚠️ AI processor initialized but disabled (no API key or explicitly disabled)');
-    }
-  }
-
-  /**
-   * 在解析前处理 - 这里我们提取 AI metadata
-   */
-  async beforeParse(content: string, fileInfo: FileInfo): Promise<string> {
-    if (!this.enabled) {
-      return content;
-    }
-
-    if (!fileInfo.hash) {
-      console.warn(`⚠️ Skipping AI processing for ${fileInfo.path}: file hash is missing`);
-      return content;
-    }
-
-    try {
-      // 检查缓存
-      const cachedMetadata = await this.aiService.getCachedMetadata(fileInfo.hash, fileInfo.path);
-      if (cachedMetadata) {
-        fileInfo.aiMetadata = cachedMetadata;
-        this.logMetadata(fileInfo.path, cachedMetadata);
-        return content;
-      }
-
-      // 调用 AI 提取 metadata
-      const metadata = await this.aiClient.extractMetadata(content, fileInfo.path);
-      if (metadata) {
-        fileInfo.aiMetadata = metadata;
-
-        // 缓存结果
-        await this.aiService.cacheMetadata(fileInfo.hash, fileInfo.path, metadata);
-
-        this.logMetadata(fileInfo.path, metadata);
-      }
-    } catch (error) {
-      console.error(`❌ AI processor failed for ${fileInfo.path}:`, error);
-    }
-
-    return content;
-  }
-
-  /**
-   * 在解析后处理 - 这里可以添加 AI 增强的 HTML 内容
-   */
-  async afterParse(html: string, fileInfo: FileInfo): Promise<string> {
-    if (!this.enabled || !fileInfo.aiMetadata) {
-      return html;
-    }
-
-    try {
-      // 可以在这里添加 AI metadata 到 HTML 中
-      // 例如：添加 meta 标签或结构化数据
-      return this.enhanceHtmlWithMetadata(html, fileInfo);
-    } catch (error) {
-      console.error(`❌ Failed to enhance HTML with AI metadata for ${fileInfo.path}:`, error);
-      return html;
-    }
-  }
-
-  /**
-   * 将 AI metadata 添加到 HTML 中
-   */
-  private enhanceHtmlWithMetadata(html: string, fileInfo: FileInfo): string {
-    const metadata = fileInfo.aiMetadata;
-    if (!metadata) {
-      return html;
-    }
-
-    // 在 head 部分添加 meta 标签
-    const metaTags = `
-<!-- AI Generated Metadata -->
-<meta name="ai-title" content="${this.escapeHtml(metadata.title)}">
-<meta name="ai-summary" content="${this.escapeHtml(metadata.summary)}">
-<meta name="ai-tags" content="${this.escapeHtml(metadata.tags.join(', '))}">
-${metadata.inferred_date ? `<meta name="ai-inferred-date" content="${metadata.inferred_date}">` : ''}
-<meta name="ai-language" content="${metadata.inferred_lang}">
-`;
-
-    // 在 body 开始处添加结构化数据
-    const structuredData = `
-<!-- AI Structured Data -->
-<script type="application/ld+json">
-{
-  "@context": "https://schema.org",
-  "@type": "Article",
-  "headline": "${this.escapeJson(metadata.title)}",
-  "description": "${this.escapeJson(metadata.summary)}",
-  "keywords": "${this.escapeJson(metadata.tags.join(', '))}",
-  "inLanguage": "${metadata.inferred_lang}"
-}
-</script>
-`;
-
-    // 插入 meta 标签到 head
-    const headEndIndex = html.indexOf('</head>');
-    if (headEndIndex !== -1) {
-      html = html.slice(0, headEndIndex) + metaTags + html.slice(headEndIndex);
-    }
-
-    // 插入结构化数据到 body 开始处
-    const bodyStartIndex = html.indexOf('<body');
-    if (bodyStartIndex !== -1) {
-      const bodyTagEndIndex = html.indexOf('>', bodyStartIndex) + 1;
-      html = html.slice(0, bodyTagEndIndex) + structuredData + html.slice(bodyTagEndIndex);
-    }
-
-    return html;
-  }
-
-  /**
-   * 转义 HTML 特殊字符
-   */
-  private escapeHtml(text: string): string {
-    return text
-      .replace(/&/g, '&amp;')
-      .replace(/</g, '&lt;')
-      .replace(/>/g, '&gt;')
-      .replace(/"/g, '&quot;')
-      .replace(/'/g, '&#039;');
-  }
-
-  /**
-   * 转义 JSON 字符串
-   */
-  private escapeJson(text: string): string {
-    return text
-      .replace(/\\/g, '\\\\')
-      .replace(/"/g, '\\"')
-      .replace(/\n/g, '\\n')
-      .replace(/\r/g, '\\r')
-      .replace(/\t/g, '\\t');
-  }
-
-  /**
-   * 记录 metadata 信息
-   */
-  private logMetadata(filePath: string, metadata: any): void {
-    console.log(`📊 AI metadata for ${filePath}:`);
-    console.log(`   Title: ${metadata.title}`);
-    console.log(`   Summary: ${metadata.summary.substring(0, 50)}...`);
-    console.log(`   Tags: ${metadata.tags.join(', ')}`);
-    if (metadata.inferred_date) {
-      console.log(`   Inferred Date: ${metadata.inferred_date}`);
-    }
-    console.log(`   Language: ${metadata.inferred_lang}`);
-  }
-
-  /**
-   * 批量处理文件
-   */
-  async processBatch(files: FileInfo[]): Promise<void> {
-    if (!this.enabled) {
-      return;
-    }
-
-    console.log(`🤖 Processing ${files.length} files with AI...`);
-
-    const filesToProcess = files.filter(file => file.hash && !file.aiMetadata);
-    if (filesToProcess.length === 0) {
-      console.log('📚 All files already have AI metadata or no files to process');
-      return;
-    }
-
-    // 准备数据
-    const fileData = filesToProcess.map(file => ({
-      content: file.content,
-      path: file.path,
-      hash: file.hash!,
-    }));
-
-    // 批量处理
-    const results = await this.aiClient.processFiles(fileData);
-
-    // 更新文件信息
-    for (const file of filesToProcess) {
-      const metadata = results.get(file.path);
-      if (metadata) {
-        file.aiMetadata = metadata;
-      }
-    }
-
-    console.log(`✅ AI processing completed for ${results.size} files`);
-  }
-
-  /**
-   * 清理缓存
-   */
-  async cleanupCache(maxAgeDays: number = 30): Promise<void> {
-    await this.aiService.cleanupCache(maxAgeDays);
-  }
-
-  /**
-   * 检查是否启用
-   */
-  isEnabled(): boolean {
-    return this.enabled;
-  }
-
-  /**
-   * 获取配置信息
-   */
-  getConfigInfo(): string {
-    const config = this.aiService.getConfig();
-    return `AI Processor Status: ${this.enabled ? 'Enabled' : 'Disabled'}
-API Key: ${config.apiKey ? 'Set' : 'Not set'}
-Base URL: ${config.baseUrl}
-Model: ${config.model}
-Temperature: ${config.temperature}
-Max Tokens: ${config.maxTokens}`;
-  }
-}

package/src/ai-service.ts

@@ -1,281 +0,0 @@
-import { AIMetadata } from './types';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as crypto from 'crypto';
-
-/**
- * AI 服务配置
- */
-export interface AIConfig {
-  enabled: boolean;
-  apiKey: string;
-  baseUrl: string;
-  model: string;
-  temperature: number;
-  maxTokens: number;
-}
-
-/**
- * 单个文件的元数据缓存项
- */
-export interface FileMetaData {
-  hash: string;
-  path: string;
-  metadata: AIMetadata;
-  lastUpdated: string;
-}
-
-/**
- * .zen/meta.json 文件结构
- */
-export interface MetaDataStore {
-  version: string;
-  timestamp: string;
-  files: FileMetaData[];
-}
-
-/**
- * AI 服务类
- */
-export class AIService {
-  private config: AIConfig;
-  private metaDataPath: string;
-
-  constructor(config: Partial<AIConfig> = {}) {
-    // 从环境变量读取配置
-    const apiKey = process.env.OPENAI_API_KEY || '';
-    const baseUrl = process.env.OPENAI_BASE_URL || 'https://api.openai.com/v1';
-
-    // 配置优先级：构造函数参数 > 环境变量 > 默认值
-    const model = config.model || process.env.OPENAI_MODEL || 'gpt-3.5-turbo';
-
-    this.config = {
-      enabled: config.enabled ?? apiKey !== '',
-      apiKey,
-      baseUrl,
-      model,
-      temperature: 0, // 总是设置为 0，提取内容不需要随机性
-      maxTokens: config.maxTokens || 500,
-    };
-
-    this.metaDataPath = path.join(process.cwd(), '.zen', 'meta.json');
-  }
-
-  /**
-   * 获取配置
-   */
-  getConfig(): AIConfig {
-    return this.config;
-  }
-
-  /**
-   * 检查是否启用 AI 功能
-   */
-  isEnabled(): boolean {
-    const enabled = this.config.enabled && this.config.apiKey !== '';
-    if (!enabled && this.config.enabled) {
-      console.warn(
-        '⚠️ AI is enabled but API key is missing. Please set OPENAI_API_KEY environment variable.'
-      );
-    }
-    return enabled;
-  }
-
-  /**
-   * 加载 .zen/meta.json 文件
-   */
-  async loadMetaData(): Promise<MetaDataStore> {
-    try {
-      await fs.access(this.metaDataPath);
-      const content = await fs.readFile(this.metaDataPath, 'utf-8');
-      return JSON.parse(content);
-    } catch (error) {
-      // 如果文件不存在，返回空结构
-      return {
-        version: '1.0.0',
-        timestamp: new Date().toISOString(),
-        files: [],
-      };
-    }
-  }
-
-  /**
-   * 保存 .zen/meta.json 文件
-   */
-  async saveMetaData(metaData: MetaDataStore): Promise<void> {
-    // 确保 .zen 目录存在
-    const zenDir = path.dirname(this.metaDataPath);
-    await fs.mkdir(zenDir, { recursive: true });
-
-    // 更新时间戳
-    metaData.timestamp = new Date().toISOString();
-
-    // 保存文件
-    await fs.writeFile(this.metaDataPath, JSON.stringify(metaData, null, 2), 'utf-8');
-  }
-
-  /**
-   * 根据文件 hash 获取缓存的 metadata
-   */
-  async getCachedMetadata(fileHash: string, filePath: string): Promise<AIMetadata | null> {
-    if (!this.isEnabled()) {
-      return null;
-    }
-
-    try {
-      const metaData = await this.loadMetaData();
-      const cachedFile = metaData.files.find(f => f.hash === fileHash);
-
-      if (cachedFile) {
-        if (cachedFile.path === filePath) {
-          // 完全匹配：hash 和 path 都相同
-          console.log(`📚 Using cached AI metadata for: ${filePath}`);
-          return cachedFile.metadata;
-        } else {
-          // 文件移动情况：hash 相同但 path 不同
-          // 更新缓存中的 path 为最新路径
-          console.log(`🔄 File moved detected: ${cachedFile.path} -> ${filePath}`);
-          await this.cacheMetadata(fileHash, filePath, cachedFile.metadata);
-          return cachedFile.metadata;
-        }
-      }
-    } catch (error) {
-      console.warn(`⚠️ Failed to load cached metadata:`, error);
-    }
-
-    return null;
-  }
-
-  /**
-   * 缓存 metadata 到 .zen/meta.json
-   */
-  async cacheMetadata(fileHash: string, filePath: string, metadata: AIMetadata): Promise<void> {
-    if (!this.isEnabled()) {
-      return;
-    }
-
-    try {
-      const metaData = await this.loadMetaData();
-
-      // 查找是否已存在相同 hash 的缓存（文件移动情况）
-      const sameHashIndex = metaData.files.findIndex(f => f.hash === fileHash);
-
-      // 查找是否已存在相同 path 但不同 hash 的缓存（文件内容更新情况）
-      const samePathIndex = metaData.files.findIndex(
-        f => f.path === filePath && f.hash !== fileHash
-      );
-
-      if (sameHashIndex >= 0) {
-        // 文件移动情况：相同 hash 但 path 可能不同
-        // 更新现有缓存项的 path 和 metadata
-        metaData.files[sameHashIndex] = {
-          hash: fileHash,
-          path: filePath,
-          metadata,
-          lastUpdated: new Date().toISOString(),
-        };
-
-        // 如果存在相同 path 但不同 hash 的旧缓存项，删除它
-        if (samePathIndex >= 0 && samePathIndex !== sameHashIndex) {
-          metaData.files.splice(samePathIndex, 1);
-        }
-      } else if (samePathIndex >= 0) {
-        // 文件内容更新情况：相同 path 但 hash 不同
-        // 删除旧的缓存项，添加新的
-        metaData.files.splice(samePathIndex, 1);
-        metaData.files.push({
-          hash: fileHash,
-          path: filePath,
-          metadata,
-          lastUpdated: new Date().toISOString(),
-        });
-      } else {
-        // 全新的文件，添加新缓存
-        metaData.files.push({
-          hash: fileHash,
-          path: filePath,
-          metadata,
-          lastUpdated: new Date().toISOString(),
-        });
-      }
-
-      await this.saveMetaData(metaData);
-      console.log(`💾 Cached AI metadata for: ${filePath}`);
-    } catch (error) {
-      console.warn(`⚠️ Failed to cache metadata:`, error);
-    }
-  }
-
-  /**
-   * 清理过期的缓存
-   */
-  async cleanupCache(maxAgeDays: number = 30): Promise<void> {
-    try {
-      const metaData = await this.loadMetaData();
-      const cutoffTime = Date.now() - maxAgeDays * 24 * 60 * 60 * 1000;
-      const originalCount = metaData.files.length;
-
-      // 过滤掉过期的缓存
-      metaData.files = metaData.files.filter(fileData => {
-        const fileTime = new Date(fileData.lastUpdated).getTime();
-        return fileTime >= cutoffTime;
-      });
-
-      const cleanedCount = originalCount - metaData.files.length;
-      if (cleanedCount > 0) {
-        await this.saveMetaData(metaData);
-        console.log(`🧹 Cleaned ${cleanedCount} expired AI metadata entries`);
-      }
-    } catch (error) {
-      console.warn(`⚠️ Failed to cleanup cache:`, error);
-    }
-  }
-
-  /**
-   * 移除孤儿条目（文件已删除但缓存仍存在）
-   * @param existingFilePaths 当前存在的文件路径列表
-   */
-  async removeOrphanEntries(existingFilePaths: string[]): Promise<void> {
-    try {
-      const metaData = await this.loadMetaData();
-      const originalCount = metaData.files.length;
-
-      // 创建现有文件路径的 Set 用于快速查找
-      const existingPathsSet = new Set(existingFilePaths);
-
-      // 过滤掉文件已经不存在的缓存条目
-      metaData.files = metaData.files.filter(fileData => {
-        return existingPathsSet.has(fileData.path);
-      });
-
-      const removedCount = originalCount - metaData.files.length;
-      if (removedCount > 0) {
-        await this.saveMetaData(metaData);
-        console.log(`🗑️ Removed ${removedCount} orphan AI metadata entries`);
-      }
-    } catch (error) {
-      console.warn(`⚠️ Failed to remove orphan entries:`, error);
-    }
-  }
-
-  /**
-   * 计算文件内容的 hash
-   */
-  calculateFileHash(content: string): string {
-    return crypto.createHash('sha256').update(content).digest('hex');
-  }
-
-  /**
-   * 打印 tokens 使用情况
-   */
-  logTokenUsage(filePath: string, tokensUsed: AIMetadata['tokens_used']): void {
-    if (!tokensUsed) {
-      return;
-    }
-
-    console.log(`🧮 Tokens usage for ${filePath}:`);
-    console.log(`   Prompt: ${tokensUsed.prompt}`);
-    console.log(`   Completion: ${tokensUsed.completion}`);
-    console.log(`   Total: ${tokensUsed.total}`);
-  }
-}