@adversity/coding-tool-x 2.3.0 → 2.4.1

package/src/server/services/enhanced-cache.js

@@ -0,0 +1,196 @@
+/**
+ * Enhanced Cache Manager
+ * 
+ * 提供全局缓存管理,支持TTL、自动清理、LRU策略
+ */
+
+class CacheManager {
+    constructor(options = {}) {
+        this.caches = new Map();
+        this.ttls = new Map();
+        this.accessTimes = new Map();
+        this.maxSize = options.maxSize || 1000; // 最大缓存条目数
+        this.defaultTTL = options.defaultTTL || 300000; // 默认5分钟
+        this.cleanupInterval = options.cleanupInterval || 60000; // 1分钟清理一次
+
+        // 启动自动清理
+        this.startCleanup();
+    }
+
+    /**
+     * 设置缓存
+     * @param {string} key - 缓存键
+     * @param {any} value - 缓存值
+     * @param {number} ttl - 过期时间(毫秒),默认使用defaultTTL
+     */
+    set(key, value, ttl) {
+        const expiryTime = Date.now() + (ttl || this.defaultTTL);
+
+        // 如果缓存已满,清理最少使用的条目
+        if (this.caches.size >= this.maxSize) {
+            this.evictLRU();
+        }
+
+        this.caches.set(key, value);
+        this.ttls.set(key, expiryTime);
+        this.accessTimes.set(key, Date.now());
+    }
+
+    /**
+     * 获取缓存
+     * @param {string} key - 缓存键
+     * @returns {any|null} 缓存值,不存在或过期返回null
+     */
+    get(key) {
+        if (!this.caches.has(key)) {
+            return null;
+        }
+
+        // 检查是否过期
+        if (Date.now() > this.ttls.get(key)) {
+            this.delete(key);
+            return null;
+        }
+
+        // 更新访问时间(LRU)
+        this.accessTimes.set(key, Date.now());
+        return this.caches.get(key);
+    }
+
+    /**
+     * 删除缓存
+     * @param {string} key - 缓存键
+     */
+    delete(key) {
+        this.caches.delete(key);
+        this.ttls.delete(key);
+        this.accessTimes.delete(key);
+    }
+
+    /**
+     * 清空所有缓存
+     */
+    clear() {
+        this.caches.clear();
+        this.ttls.clear();
+        this.accessTimes.clear();
+    }
+
+    /**
+     * 检查缓存是否存在且有效
+     * @param {string} key - 缓存键
+     * @returns {boolean}
+     */
+    has(key) {
+        return this.get(key) !== null;
+    }
+
+    /**
+     * 获取或设置缓存(如果不存在则调用工厂函数)
+     * @param {string} key - 缓存键
+     * @param {Function} factory - 工厂函数,返回值或Promise
+     * @param {number} ttl - 过期时间
+     * @returns {any|Promise<any>}
+     */
+    async getOrSet(key, factory, ttl) {
+        const cached = this.get(key);
+        if (cached !== null) {
+            return cached;
+        }
+
+        const value = await factory();
+        this.set(key, value, ttl);
+        return value;
+    }
+
+    /**
+     * LRU驱逐策略:移除最久未使用的条目
+     */
+    evictLRU() {
+        let oldestKey = null;
+        let oldestTime = Infinity;
+
+        for (const [key, accessTime] of this.accessTimes) {
+            if (accessTime < oldestTime) {
+                oldestTime = accessTime;
+                oldestKey = key;
+            }
+        }
+
+        if (oldestKey) {
+            this.delete(oldestKey);
+        }
+    }
+
+    /**
+     * 启动自动清理过期缓存
+     */
+    startCleanup() {
+        this.cleanupTimer = setInterval(() => {
+            const now = Date.now();
+            const expiredKeys = [];
+
+            for (const [key, expiryTime] of this.ttls) {
+                if (now > expiryTime) {
+                    expiredKeys.push(key);
+                }
+            }
+
+            expiredKeys.forEach(key => this.delete(key));
+
+            if (expiredKeys.length > 0) {
+                console.log(`[CacheManager] Cleaned up ${expiredKeys.length} expired entries`);
+            }
+        }, this.cleanupInterval);
+
+        // 确保Node.js进程退出时清理定时器
+        if (this.cleanupTimer.unref) {
+            this.cleanupTimer.unref();
+        }
+    }
+
+    /**
+     * 停止自动清理
+     */
+    stopCleanup() {
+        if (this.cleanupTimer) {
+            clearInterval(this.cleanupTimer);
+            this.cleanupTimer = null;
+        }
+    }
+
+    /**
+     * 获取缓存统计信息
+     * @returns {object}
+     */
+    getStats() {
+        return {
+            size: this.caches.size,
+            maxSize: this.maxSize,
+            keys: Array.from(this.caches.keys())
+        };
+    }
+}
+
+// 创建全局缓存实例
+const globalCache = new CacheManager({
+    maxSize: 1000,
+    defaultTTL: 300000, // 5分钟
+    cleanupInterval: 60000 // 1分钟
+});
+
+// 预定义的缓存键前缀
+const CacheKeys = {
+    PROJECTS: 'projects:',
+    SESSIONS: 'sessions:',
+    SKILLS: 'skills:',
+    CONFIG_TEMPLATES: 'config-templates:',
+    REPOS: 'repos:',
+    HAS_MESSAGES: 'has-messages:'
+};
+
+module.exports = {
+    CacheManager,
+    globalCache,
+    CacheKeys
+};

package/src/server/services/health-check.js

@@ -1,7 +1,5 @@
 const fs = require('fs');
 const path = require('path');
-const os = require('os');
-const readline = require('readline');
 
 /**
  * 健康检查：确保项目的 .claude/sessions 目录存在
@@ -81,319 +79,7 @@ function healthCheckAllProjects(projects) {
   };
 }
 
-/**
- * 从会话文件中提取 cwd
- * @param {string} sessionFilePath - 会话文件路径
- * @returns {string|null} cwd 或 null
- */
-function extractCwdFromSession(sessionFilePath) {
-  try {
-    const content = fs.readFileSync(sessionFilePath, 'utf8');
-    const firstLine = content.split('\n')[0];
-    if (firstLine) {
-      const json = JSON.parse(firstLine);
-      return json.cwd || null;
-    }
-  } catch (err) {
-    // Ignore parse errors
-  }
-  return null;
-}
-
-/**
- * 扫描旧的全局目录中的会话文件
- * @returns {Object} 扫描结果
- */
-function scanLegacySessionFiles() {
-  try {
-    const legacyProjectsDir = path.join(os.homedir(), '.claude', 'projects');
-
-    if (!fs.existsSync(legacyProjectsDir)) {
-      return {
-        found: false,
-        message: 'Legacy directory not found (nothing to clean)',
-        legacyDir: legacyProjectsDir
-      };
-    }
-
-    const projects = [];
-    const entries = fs.readdirSync(legacyProjectsDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-
-      const projectName = entry.name;
-      const projectDir = path.join(legacyProjectsDir, projectName);
-      const files = fs.readdirSync(projectDir)
-        .filter(f => f.endsWith('.jsonl') || f.endsWith('.json'));
-
-      if (files.length > 0) {
-        let totalSize = 0;
-        for (const file of files) {
-          const filePath = path.join(projectDir, file);
-          const stats = fs.statSync(filePath);
-          totalSize += stats.size;
-        }
-
-        projects.push({
-          projectName,
-          projectDir,
-          fileCount: files.length,
-          totalSize,
-          files: files.slice(0, 5) // 只显示前5个文件名
-        });
-      }
-    }
-
-    return {
-      found: true,
-      legacyDir: legacyProjectsDir,
-      projectCount: projects.length,
-      projects
-    };
-  } catch (err) {
-    return {
-      found: false,
-      error: err.message
-    };
-  }
-}
-
-/**
- * 迁移会话文件到正确的位置
- * @param {Object} options - 迁移选项
- * @returns {Object} 迁移结果
- */
-function migrateSessionFiles(options = {}) {
-  const {
-    dryRun = false,  // 是否只是预演
-    projectNames = null  // 指定要迁移的项目
-  } = options;
-
-  try {
-    const legacyProjectsDir = path.join(os.homedir(), '.claude', 'projects');
-
-    if (!fs.existsSync(legacyProjectsDir)) {
-      return {
-        success: true,
-        message: 'No legacy directory found',
-        migrated: 0
-      };
-    }
-
-    const results = {
-      dryRun,
-      migrated: [],
-      skipped: [],
-      errors: []
-    };
-
-    const entries = fs.readdirSync(legacyProjectsDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-
-      const projectName = entry.name;
-
-      // 如果指定了项目列表，只迁移列表中的项目
-      if (projectNames && !projectNames.includes(projectName)) {
-        continue;
-      }
-
-      const projectDir = path.join(legacyProjectsDir, projectName);
-      const files = fs.readdirSync(projectDir)
-        .filter(f => f.endsWith('.jsonl'));
-
-      for (const file of files) {
-        const oldPath = path.join(projectDir, file);
-
-        try {
-          // 从会话文件提取 cwd
-          const cwd = extractCwdFromSession(oldPath);
-
-          if (!cwd || !fs.existsSync(cwd)) {
-            results.skipped.push({
-              file,
-              reason: 'Invalid or missing cwd',
-              oldPath
-            });
-            continue;
-          }
-
-          // 目标路径: {cwd}/.claude/sessions/{file}
-          const targetDir = path.join(cwd, '.claude', 'sessions');
-          const newPath = path.join(targetDir, file);
-
-          // 如果文件已存在，跳过
-          if (fs.existsSync(newPath)) {
-            results.skipped.push({
-              file,
-              reason: 'Already exists at target',
-              oldPath,
-              newPath
-            });
-            continue;
-          }
-
-          if (!dryRun) {
-            // 确保目标目录存在
-            if (!fs.existsSync(targetDir)) {
-              fs.mkdirSync(targetDir, { recursive: true });
-            }
-
-            // 复制文件（保留原文件）
-            fs.copyFileSync(oldPath, newPath);
-            console.log(`[Migration] Migrated: ${file} -> ${newPath}`);
-          }
-
-          results.migrated.push({
-            file,
-            oldPath,
-            newPath,
-            cwd
-          });
-        } catch (err) {
-          results.errors.push({
-            file,
-            oldPath,
-            error: err.message
-          });
-        }
-      }
-    }
-
-    return {
-      success: true,
-      dryRun,
-      migratedCount: results.migrated.length,
-      skippedCount: results.skipped.length,
-      errorCount: results.errors.length,
-      results
-    };
-  } catch (err) {
-    return {
-      success: false,
-      error: err.message
-    };
-  }
-}
-
-/**
- * 清理旧的全局目录中的会话文件
- * @param {Object} options - 清理选项
- * @returns {Object} 清理结果
- */
-function cleanLegacySessionFiles(options = {}) {
-  const {
-    dryRun = false,  // 是否只是预演，不实际删除
-    projectNames = null  // 指定要清理的项目名称列表，null 表示全部
-  } = options;
-
-  try {
-    const legacyProjectsDir = path.join(os.homedir(), '.claude', 'projects');
-
-    if (!fs.existsSync(legacyProjectsDir)) {
-      return {
-        success: true,
-        message: 'No legacy directory found',
-        deleted: 0
-      };
-    }
-
-    const results = {
-      dryRun,
-      deleted: [],
-      errors: [],
-      totalSize: 0
-    };
-
-    const entries = fs.readdirSync(legacyProjectsDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-
-      const projectName = entry.name;
-
-      // 如果指定了项目列表，只清理列表中的项目
-      if (projectNames && !projectNames.includes(projectName)) {
-        continue;
-      }
-
-      const projectDir = path.join(legacyProjectsDir, projectName);
-      const files = fs.readdirSync(projectDir);
-
-      for (const file of files) {
-        const filePath = path.join(projectDir, file);
-
-        try {
-          const stats = fs.statSync(filePath);
-          results.totalSize += stats.size;
-
-          if (!dryRun) {
-            fs.unlinkSync(filePath);
-          }
-
-          results.deleted.push({
-            projectName,
-            file,
-            size: stats.size
-          });
-        } catch (err) {
-          results.errors.push({
-            projectName,
-            file,
-            error: err.message
-          });
-        }
-      }
-
-      // 如果项目目录为空，删除目录
-      if (!dryRun) {
-        try {
-          const remainingFiles = fs.readdirSync(projectDir);
-          if (remainingFiles.length === 0) {
-            fs.rmdirSync(projectDir);
-            console.log(`[Cleanup] Removed empty directory: ${projectDir}`);
-          }
-        } catch (err) {
-          console.warn(`[Cleanup] Failed to remove directory ${projectDir}:`, err.message);
-        }
-      }
-    }
-
-    // 如果 projects 目录为空，删除它
-    if (!dryRun) {
-      try {
-        const remainingProjects = fs.readdirSync(legacyProjectsDir);
-        if (remainingProjects.length === 0) {
-          fs.rmdirSync(legacyProjectsDir);
-          console.log(`[Cleanup] Removed empty legacy directory: ${legacyProjectsDir}`);
-        }
-      } catch (err) {
-        console.warn(`[Cleanup] Failed to remove legacy directory:`, err.message);
-      }
-    }
-
-    return {
-      success: true,
-      dryRun,
-      deletedCount: results.deleted.length,
-      errorCount: results.errors.length,
-      totalSize: results.totalSize,
-      results
-    };
-  } catch (err) {
-    return {
-      success: false,
-      error: err.message
-    };
-  }
-}
-
 module.exports = {
   ensureProjectClaudeDir,
-  healthCheckAllProjects,
-  scanLegacySessionFiles,
-  migrateSessionFiles,
-  cleanLegacySessionFiles
+  healthCheckAllProjects
 };