autosnippet 2.19.4 → 2.19.6

package/bin/cli.js

@@ -5,6 +5,7 @@
  * 
  * Usage:
  *   asd setup           - 初始化项目
+ *   asd coldstart       - 冷启动知识库（9 维度分析 + AI 填充）
  *   asd ais [Target]    - AI 扫描 Target → 直接发布 Recipes
  *   asd search <query>  - 搜索知识库
  *   asd guard <file>    - Guard 检查
@@ -73,6 +74,182 @@ program
     service.printSummary();
   });
 
+// ─────────────────────────────────────────────────────
+// coldstart 命令 (Knowledge Bootstrap)
+// ─────────────────────────────────────────────────────
+program
+  .command('coldstart')
+  .description('冷启动知识库：9 维度项目分析 + AI 异步填充（与 Dashboard 点击冷启动流程一致）')
+  .option('-d, --dir <path>', '项目目录', '.')
+  .option('-m, --max-files <n>', '最大扫描文件数', '500')
+  .option('--skip-guard', '跳过 Guard 审计')
+  .option('--no-skills', '禁用 Skill 加载')
+  .option('--wait', '等待 AI 异步填充完成（默认骨架完成即退出）')
+  .option('--json', '以 JSON 格式输出结果')
+  .action(async (opts) => {
+    const projectRoot = resolve(opts.dir);
+    console.log(`\n🚀 AutoSnippet — 冷启动知识库`);
+    console.log(`   项目: ${basename(projectRoot)}`);
+    console.log(`   路径: ${projectRoot}`);
+    console.log(`   最大文件数: ${opts.maxFiles}`);
+    if (opts.skipGuard) console.log('   Guard 审计: 跳过');
+    console.log('');
+
+    try {
+      const { bootstrap, container } = await initContainer({ projectRoot });
+
+      // 使用与前端 POST /spm/bootstrap 完全相同的入口: chatAgent.executeTool('bootstrap_knowledge')
+      const chatAgent = container.get('chatAgent');
+
+      const ora = (await import('ora')).default;
+      const spinner = ora('Phase 1-4: 收集文件、AST 分析、SPM 依赖、Guard 审计...').start();
+
+      const result = await chatAgent.executeTool('bootstrap_knowledge', {
+        maxFiles: parseInt(opts.maxFiles, 10),
+        skipGuard: opts.skipGuard || false,
+        contentMaxLines: 120,
+        loadSkills: opts.skills !== false,
+      });
+
+      spinner.stop();
+
+      if (opts.json) {
+        console.log(JSON.stringify(result, null, 2));
+      } else {
+        // 输出骨架报告
+        const report = result.report || {};
+        const targets = result.targets || [];
+        const langStats = result.languageStats || {};
+        const guardSummary = result.guardSummary;
+        const astSummary = result.astSummary;
+        const bootstrapCandidates = result.bootstrapCandidates || {};
+        const framework = result.analysisFramework || {};
+
+        console.log('✅ 冷启动骨架已创建\n');
+
+        // 项目概况
+        console.log('📊 项目概况');
+        console.log(`   Targets: ${targets.length}`);
+        console.log(`   文件: ${report.totals?.files || 0}`);
+        console.log(`   主语言: ${result.primaryLanguage || 'unknown'}`);
+        if (Object.keys(langStats).length > 0) {
+          const langParts = Object.entries(langStats)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([ext, count]) => `${ext}(${count})`);
+          console.log(`   语言分布: ${langParts.join(', ')}`);
+        }
+
+        // AST 分析
+        if (astSummary) {
+          console.log(`\n🔬 AST 分析`);
+          console.log(`   类: ${astSummary.classes}, 协议: ${astSummary.protocols}, Category: ${astSummary.categories}`);
+          if (astSummary.metrics) {
+            console.log(`   方法总数: ${astSummary.metrics.totalMethods}, 复杂方法: ${astSummary.metrics.complexMethods}`);
+          }
+        }
+
+        // SPM 依赖
+        if (report.phases?.spmDependencyGraph) {
+          console.log(`\n📦 SPM 依赖`);
+          console.log(`   依赖边: ${report.phases.spmDependencyGraph.edgesWritten}`);
+        }
+
+        // Guard 审计
+        if (guardSummary) {
+          console.log(`\n🛡️  Guard 审计`);
+          console.log(`   违规: ${guardSummary.totalViolations} (${guardSummary.errors} errors, ${guardSummary.warnings} warnings)`);
+        }
+
+        // 维度分析框架
+        if (framework.dimensions) {
+          console.log(`\n📋 分析维度: ${framework.dimensions.length} 个`);
+          for (const dim of framework.dimensions) {
+            const type = dim.skillWorthy ? (dim.dualOutput ? 'Dual' : 'Skill') : 'Candidate';
+            console.log(`   • ${dim.label} [${type}]`);
+          }
+        }
+
+        // AI 异步填充状态
+        console.log(`\n🤖 AI 异步填充: ${result.asyncFill ? '已启动' : '未启用'}`);
+        if (result.bootstrapSession) {
+          const session = result.bootstrapSession;
+          console.log(`   会话: ${session.id}`);
+          console.log(`   任务: ${session.tasks?.length || 0} 个维度`);
+        }
+
+        console.log('');
+      }
+
+      // 等待模式: 轮询 BootstrapTaskManager 直到所有维度完成
+      if (opts.wait && result.bootstrapSession) {
+        const ora2 = (await import('ora')).default;
+        const waitSpinner = ora2('Phase 5: AI 正在逐维度填充知识...').start();
+        let lastStatus = '';
+        let attempts = 0;
+        const maxAttempts = 600; // 最多等 10 分钟（每秒轮询）
+
+        while (attempts < maxAttempts) {
+          await new Promise(r => setTimeout(r, 1000));
+          attempts++;
+
+          try {
+            const taskManager = container.get('bootstrapTaskManager');
+            const sessionStatus = taskManager.getSessionStatus();
+
+            if (!sessionStatus || !sessionStatus.tasks) break;
+
+            const total = sessionStatus.tasks.length;
+            const done = sessionStatus.tasks.filter(t => t.status === 'done' || t.status === 'error').length;
+            const current = sessionStatus.tasks.find(t => t.status === 'running');
+            const statusText = current
+              ? `[${done}/${total}] 正在处理: ${current.meta?.label || current.id}`
+              : `[${done}/${total}] 等待中...`;
+
+            if (statusText !== lastStatus) {
+              waitSpinner.text = statusText;
+              lastStatus = statusText;
+            }
+
+            if (done >= total) {
+              waitSpinner.succeed(`AI 填充完成: ${total} 个维度`);
+
+              // 输出各维度结果
+              if (!opts.json) {
+                const succeeded = sessionStatus.tasks.filter(t => t.status === 'done').length;
+                const failed = sessionStatus.tasks.filter(t => t.status === 'error').length;
+                console.log(`   ✅ 成功: ${succeeded}, ❌ 失败: ${failed}`);
+                for (const t of sessionStatus.tasks) {
+                  const icon = t.status === 'done' ? '✅' : '❌';
+                  console.log(`   ${icon} ${t.meta?.label || t.id}`);
+                }
+                console.log('');
+              }
+              break;
+            }
+          } catch {
+            // bootstrapTaskManager 可能还没就绪
+          }
+        }
+
+        if (attempts >= maxAttempts) {
+          waitSpinner.warn('AI 填充超时（10 分钟），可通过 asd ui 查看进度');
+        }
+      } else if (!opts.json) {
+        console.log('💡 后台 AI 正在逐维度填充知识，可通过以下方式查看进度:');
+        console.log('   • asd ui -d .    → Dashboard 实时查看');
+        console.log('   • 再次运行 asd coldstart --wait 等待完成');
+        console.log('');
+      }
+
+      await bootstrap.shutdown();
+    } catch (err) {
+      console.error(`\n❌ ${err.message}`);
+      if (process.env.ASD_DEBUG === '1') console.error(err.stack);
+      process.exit(1);
+    }
+  });
+
 // ─────────────────────────────────────────────────────
 // ais 命令 (AI Scan)
 // ─────────────────────────────────────────────────────

package/lib/http/HttpServer.js

@@ -31,7 +31,6 @@ import knowledgeRouter from './routes/knowledge.js';
 import recipesRouter from './routes/recipes.js';
 import wikiRouter from './routes/wiki.js';
 import apiSpec from './api-spec.js';
-import { initRedisService } from '../infrastructure/cache/RedisService.js';
 import { initCacheAdapter } from '../infrastructure/cache/UnifiedCacheAdapter.js';
 import { initPerformanceMonitor } from '../infrastructure/monitoring/PerformanceMonitor.js';
 import { initErrorTracker } from '../infrastructure/monitoring/ErrorTracker.js';
@@ -44,9 +43,8 @@ export class HttpServer {
     this.config = {
       port: config.port || 3000,
       host: config.host || 'localhost',
-      enableRedis: config.enableRedis !== false,
       enableMonitoring: config.enableMonitoring !== false,
-      cacheMode: config.cacheMode || process.env.CACHE_MODE || 'memory',
+      cacheMode: 'memory',
       ...config,
     };
     
@@ -92,27 +90,9 @@ export class HttpServer {
    */
   async initializeServices() {
     try {
-      // 初始化 Redis（如果启用）
-      if (this.config.enableRedis && this.config.cacheMode === 'redis') {
-        try {
-          await initRedisService({
-            host: process.env.REDIS_HOST,
-            port: process.env.REDIS_PORT,
-            password: process.env.REDIS_PASSWORD,
-          });
-          this.logger.info('Redis service initialized');
-        } catch (error) {
-          this.logger.warn('Redis initialization failed, falling back to memory cache', {
-            error: error.message,
-          });
-          this.config.cacheMode = 'memory';
-        }
-      }
-
-      // 初始化缓存适配器
+      // 初始化缓存适配器（纯内存模式）
       this.cacheAdapter = await initCacheAdapter({
-        mode: this.config.cacheMode,
-        fallbackToMemory: true,
+        mode: 'memory',
       });
       this.logger.info('Cache adapter initialized');
 
@@ -288,13 +268,13 @@ export class HttpServer {
       });
     });
 
-    // 404 处理
-    this.app.use('*', (req, res) => {
+    // 404 处理（使用 app.all 确保 layer.route 存在，mountDashboard 依赖此属性定位并重排路由栈）
+    this.app.all('*', (req, res) => {
       res.status(404).json({
         success: false,
         error: {
           code: 'NOT_FOUND',
-          message: `Route not found: ${req.method} ${req.path}`,
+          message: `Route not found: ${req.method} ${req.originalUrl}`,
         },
       });
     });

package/lib/http/routes/commands.js

@@ -26,14 +26,16 @@ router.post('/install', asyncHandler(async (req, res) => {
     { status: 'active' },
     { page: 1, pageSize: 9999 },
   );
-  const recipes = (result?.data || result?.items || []).map(r => ({
-    id: r.id,
-    title: r.title,
-    trigger: r.trigger,
-    code: r.content?.pattern || '',
-    description: r.description || r.summaryCn || '',
-    language: r.language || 'swift',
-  }));
+  const recipes = (result?.data || result?.items || [])
+    .map(r => ({
+      id: r.id,
+      title: r.title,
+      trigger: r.trigger,
+      code: r.content?.pattern || '',
+      description: r.description || r.summaryCn || '',
+      language: r.language || 'swift',
+    }))
+    .filter(r => r.code.trim().length > 0); // 跳过没有代码内容的 Recipe
 
   const installResult = snippetInstaller.installFromRecipes(recipes);
 

package/lib/infrastructure/cache/UnifiedCacheAdapter.js

@@ -1,77 +1,30 @@
 /**
  * 统一缓存适配器
- * 支持内存缓存和 Redis 缓存的无缝切换
+ * 内存缓存模式
  */
 
 import { cacheService as memoryCacheService } from './CacheService.js';
-import { getRedisService } from './RedisService.js';
 import Logger from '../logging/Logger.js';
 
 export class UnifiedCacheAdapter {
-  constructor(options = {}) {
-    this.mode = options.mode || process.env.CACHE_MODE || 'memory'; // 'memory' | 'redis'
-    this.fallbackToMemory = options.fallbackToMemory !== false;
-    this.redisService = null;
+  constructor() {
+    this.mode = 'memory';
     this.memoryService = memoryCacheService;
-
-    Logger.info(`缓存模式: ${this.mode}${this.fallbackToMemory ? ' (支持降级到内存)' : ''}`);
   }
 
   /**
    * 初始化缓存服务
    */
   async initialize() {
-    if (this.mode === 'redis') {
-      try {
-        this.redisService = getRedisService();
-        const health = await this.redisService.healthCheck();
-        if (!health.healthy) {
-          throw new Error(health.message);
-        }
-        Logger.info('✅ Redis 缓存已启用');
-      } catch (error) {
-        Logger.error('Redis 初始化失败:', { error: error.message });
-        if (this.fallbackToMemory) {
-          Logger.warn('⚠️  降级为内存缓存模式');
-          this.mode = 'memory';
-        } else {
-          throw error;
-        }
-      }
-    } else {
-      Logger.info('✅ 内存缓存已启用');
-    }
-  }
-
-  /**
-   * 获取当前活动的缓存服务
-   */
-  _getActiveService() {
-    if (this.mode === 'redis' && this.redisService && this.redisService.isConnected) {
-      return this.redisService;
-    }
-
-    // memory 模式下直接返回内存服务，或 redis 回退到内存
-    if (this.mode === 'memory' || this.fallbackToMemory) {
-      return this.memoryService;
-    }
-
-    return null;
+    Logger.info('✅ 内存缓存已启用');
   }
 
   /**
    * 获取缓存值
    */
   async get(key) {
-    const service = this._getActiveService();
-    if (!service) return null;
-
     try {
-      if (this.mode === 'redis') {
-        return await service.get(key);
-      } else {
-        return service.get(key);
-      }
+      return this.memoryService.get(key);
     } catch (error) {
       Logger.error(`缓存获取失败 (${key}):`, { error: error.message });
       return null;
@@ -82,16 +35,9 @@ export class UnifiedCacheAdapter {
    * 设置缓存值
    */
   async set(key, value, ttlSeconds = 300) {
-    const service = this._getActiveService();
-    if (!service) return false;
-
     try {
-      if (this.mode === 'redis') {
-        return await service.set(key, value, ttlSeconds);
-      } else {
-        service.set(key, value, ttlSeconds);
-        return true;
-      }
+      this.memoryService.set(key, value, ttlSeconds);
+      return true;
     } catch (error) {
       Logger.error(`缓存设置失败 (${key}):`, { error: error.message });
       return false;
@@ -102,15 +48,8 @@ export class UnifiedCacheAdapter {
    * 删除缓存
    */
   async delete(key) {
-    const service = this._getActiveService();
-    if (!service) return false;
-
     try {
-      if (this.mode === 'redis') {
-        return await service.delete(key);
-      } else {
-        return service.delete(key);
-      }
+      return this.memoryService.delete(key);
     } catch (error) {
       Logger.error(`缓存删除失败 (${key}):`, { error: error.message });
       return false;
@@ -121,16 +60,9 @@ export class UnifiedCacheAdapter {
    * 清空所有缓存
    */
   async clear() {
-    const service = this._getActiveService();
-    if (!service) return false;
-
     try {
-      if (this.mode === 'redis') {
-        return await service.clear();
-      } else {
-        service.clear();
-        return true;
-      }
+      this.memoryService.clear();
+      return true;
     } catch (error) {
       Logger.error('缓存清空失败:', { error: error.message });
       return false;
@@ -141,34 +73,15 @@ export class UnifiedCacheAdapter {
    * 获取统计信息
    */
   getStats() {
-    const service = this._getActiveService();
-    if (!service) {
-      return { mode: this.mode, available: false };
-    }
-
-    const stats = service.getStats();
-    return { mode: this.mode, available: true, ...stats };
+    const stats = this.memoryService.getStats();
+    return { mode: 'memory', available: true, ...stats };
   }
 
   /**
    * 健康检查
    */
   async healthCheck() {
-    const service = this._getActiveService();
-    if (!service) {
-      return { healthy: false, mode: this.mode, message: '缓存服务不可用' };
-    }
-
-    try {
-      if (this.mode === 'redis') {
-        const health = await service.healthCheck();
-        return { ...health, mode: 'redis' };
-      } else {
-        return { healthy: true, mode: 'memory', message: '内存缓存运行正常' };
-      }
-    } catch (error) {
-      return { healthy: false, mode: this.mode, message: error.message };
-    }
+    return { healthy: true, mode: 'memory', message: '内存缓存运行正常' };
   }
 }
 
@@ -178,13 +91,13 @@ let cacheAdapterInstance = null;
 /**
  * 初始化统一缓存适配器
  */
-export async function initCacheAdapter(options) {
+export async function initCacheAdapter() {
   if (cacheAdapterInstance) {
     Logger.warn('缓存适配器已初始化');
     return cacheAdapterInstance;
   }
 
-  cacheAdapterInstance = new UnifiedCacheAdapter(options);
+  cacheAdapterInstance = new UnifiedCacheAdapter();
   await cacheAdapterInstance.initialize();
   return cacheAdapterInstance;
 }

package/lib/infrastructure/config/Defaults.js

@@ -14,7 +14,7 @@ export const SPMMAP_PATH = `AutoSnippet/${SPMMAP_FILENAME}`;
 
 // ─── Context 存储 ────────────────────────────────────────────
 export const DEFAULT_STORAGE_ADAPTER = 'json';
-export const STORAGE_ADAPTERS = ['json', 'milvus'];
+export const STORAGE_ADAPTERS = ['json'];
 
 // ─── Context 索引 ────────────────────────────────────────────
 export const SOURCE_TYPES = ['recipe', 'doc', 'target-readme'];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autosnippet",
-  "version": "2.19.4",
+  "version": "2.19.6",
   "description": "AutoSnippet - 连接开发者、AI 与项目知识库的工具",
   "type": "module",
   "main": "lib/bootstrap.js",
@@ -55,7 +55,6 @@
   "dependencies": {
     "@google/generative-ai": "^0.21.0",
     "@modelcontextprotocol/sdk": "^1.25.3",
-    "@zilliz/milvus2-sdk-node": "^2.5.10",
     "axios": "^1.6.7",
     "better-sqlite3": "^9.2.2",
     "chalk": "^5.3.0",
@@ -70,7 +69,6 @@
     "minimist": "^1.2.5",
     "open": "^8.0.4",
     "ora": "^8.0.1",
-    "redis": "^4.7.0",
     "socket.io": "^4.8.1",
     "tree-sitter": "^0.22.4",
     "tree-sitter-objc": "^3.0.2",
@@ -78,7 +76,6 @@
     "undici": "^6.23.0",
     "uuid": "^9.0.1",
     "winston": "^3.11.0",
-    "xml2js": "^0.6.2",
     "zod": "^4.3.6"
   },
   "bugs": {

package/lib/infrastructure/cache/RedisService.js

@@ -1,365 +0,0 @@
-/**
- * Redis 缓存服务
- * 提供 Redis 客户端封装，支持分布式缓存
- */
-
-import { createClient } from 'redis';
-import Logger from '../logging/Logger.js';
-
-export class RedisService {
-  constructor(config = {}) {
-    this.config = {
-      host: config.host || process.env.REDIS_HOST || 'localhost',
-      port: parseInt(config.port || process.env.REDIS_PORT || 6379, 10),
-      password: config.password || process.env.REDIS_PASSWORD,
-      db: parseInt(config.db || process.env.REDIS_DB || 0, 10),
-      keyPrefix: config.keyPrefix || 'asd:',
-      retryStrategy: config.retryStrategy || this.defaultRetryStrategy.bind(this),
-      connectTimeout: config.connectTimeout || 10000,
-    };
-
-    this.client = null;
-    this.isConnected = false;
-    this.stats = {
-      hits: 0,
-      misses: 0,
-      sets: 0,
-      deletes: 0,
-      errors: 0,
-    };
-  }
-
-  /**
-   * 默认重试策略
-   */
-  defaultRetryStrategy(retries) {
-    if (retries > 10) {
-      Logger.error('Redis 重连失败次数过多，停止重试');
-      return new Error('Redis 重连失败');
-    }
-    const delay = Math.min(retries * 100, 3000);
-    Logger.info(`Redis 重连中... (第 ${retries} 次，延迟 ${delay}ms)`);
-    return delay;
-  }
-
-  /**
-   * 连接到 Redis
-   */
-  async connect() {
-    if (this.isConnected) {
-      return;
-    }
-
-    try {
-      this.client = createClient({
-        socket: {
-          host: this.config.host,
-          port: this.config.port,
-          connectTimeout: this.config.connectTimeout,
-          reconnectStrategy: (retries) => this.config.retryStrategy(retries),
-        },
-        password: this.config.password || undefined,
-        database: this.config.db,
-      });
-
-      this.client.on('error', (err) => {
-        Logger.error('Redis 客户端错误:', { error: err.message });
-        this.stats.errors++;
-        this.isConnected = false;
-      });
-
-      this.client.on('connect', () => {
-        Logger.info(`Redis 连接成功: ${this.config.host}:${this.config.port}`);
-      });
-
-      this.client.on('ready', () => {
-        Logger.info('Redis 客户端准备就绪');
-        this.isConnected = true;
-      });
-
-      this.client.on('reconnecting', () => {
-        Logger.warn('Redis 重新连接中...');
-        this.isConnected = false;
-      });
-
-      this.client.on('end', () => {
-        Logger.warn('Redis 连接已关闭');
-        this.isConnected = false;
-      });
-
-      await this.client.connect();
-      Logger.info('✅ Redis 服务已启动');
-    } catch (error) {
-      Logger.error('Redis 连接失败:', { error: error.message });
-      this.stats.errors++;
-      throw error;
-    }
-  }
-
-  /**
-   * 生成完整键名
-   */
-  _getKey(key) {
-    return `${this.config.keyPrefix}${key}`;
-  }
-
-  /**
-   * 获取缓存值
-   */
-  async get(key) {
-    if (!this.isConnected) {
-      this.stats.misses++;
-      return null;
-    }
-
-    try {
-      const fullKey = this._getKey(key);
-      const value = await this.client.get(fullKey);
-
-      if (value === null) {
-        this.stats.misses++;
-        return null;
-      }
-
-      this.stats.hits++;
-      return JSON.parse(value);
-    } catch (error) {
-      Logger.error(`Redis GET 失败 (${key}):`, { error: error.message });
-      this.stats.errors++;
-      this.stats.misses++;
-      return null;
-    }
-  }
-
-  /**
-   * 设置缓存值
-   */
-  async set(key, value, ttlSeconds = 300) {
-    if (!this.isConnected) {
-      return false;
-    }
-
-    try {
-      const fullKey = this._getKey(key);
-      const serialized = JSON.stringify(value);
-
-      if (ttlSeconds > 0) {
-        await this.client.setEx(fullKey, ttlSeconds, serialized);
-      } else {
-        await this.client.set(fullKey, serialized);
-      }
-
-      this.stats.sets++;
-      return true;
-    } catch (error) {
-      Logger.error(`Redis SET 失败 (${key}):`, { error: error.message });
-      this.stats.errors++;
-      return false;
-    }
-  }
-
-  /**
-   * 删除缓存
-   */
-  async delete(key) {
-    if (!this.isConnected) {
-      return false;
-    }
-
-    try {
-      const fullKey = this._getKey(key);
-      await this.client.del(fullKey);
-      this.stats.deletes++;
-      return true;
-    } catch (error) {
-      Logger.error(`Redis DEL 失败 (${key}):`, { error: error.message });
-      this.stats.errors++;
-      return false;
-    }
-  }
-
-  /**
-   * 批量删除（通配符，使用 SCAN）
-   */
-  async deletePattern(pattern) {
-    if (!this.isConnected) {
-      return 0;
-    }
-
-    try {
-      const fullPattern = this._getKey(pattern);
-      const keys = [];
-
-      for await (const key of this.client.scanIterator({
-        MATCH: fullPattern,
-        COUNT: 100,
-      })) {
-        keys.push(key);
-      }
-
-      if (keys.length > 0) {
-        await this.client.del(keys);
-        this.stats.deletes += keys.length;
-      }
-
-      return keys.length;
-    } catch (error) {
-      Logger.error(`Redis 批量删除失败 (${pattern}):`, { error: error.message });
-      this.stats.errors++;
-      return 0;
-    }
-  }
-
-  /**
-   * 清空所有缓存
-   */
-  async clear() {
-    if (!this.isConnected) {
-      return false;
-    }
-
-    try {
-      const deletedCount = await this.deletePattern('*');
-      Logger.info(`Redis 缓存已清空 (${deletedCount} 个键)`);
-      return true;
-    } catch (error) {
-      Logger.error('Redis 清空缓存失败:', { error: error.message });
-      this.stats.errors++;
-      return false;
-    }
-  }
-
-  /**
-   * 检查键是否存在
-   */
-  async exists(key) {
-    if (!this.isConnected) {
-      return false;
-    }
-
-    try {
-      const fullKey = this._getKey(key);
-      const result = await this.client.exists(fullKey);
-      return result === 1;
-    } catch (error) {
-      Logger.error(`Redis EXISTS 失败 (${key}):`, { error: error.message });
-      this.stats.errors++;
-      return false;
-    }
-  }
-
-  /**
-   * 获取剩余 TTL
-   */
-  async ttl(key) {
-    if (!this.isConnected) {
-      return -1;
-    }
-
-    try {
-      const fullKey = this._getKey(key);
-      return await this.client.ttl(fullKey);
-    } catch (error) {
-      Logger.error(`Redis TTL 失败 (${key}):`, { error: error.message });
-      this.stats.errors++;
-      return -1;
-    }
-  }
-
-  /**
-   * 获取统计信息
-   */
-  getStats() {
-    const totalRequests = this.stats.hits + this.stats.misses;
-    const hitRate = totalRequests > 0 ? (this.stats.hits / totalRequests) * 100 : 0;
-
-    return {
-      ...this.stats,
-      totalRequests,
-      hitRate: hitRate.toFixed(2) + '%',
-      isConnected: this.isConnected,
-      config: {
-        host: this.config.host,
-        port: this.config.port,
-        db: this.config.db,
-        keyPrefix: this.config.keyPrefix,
-      },
-    };
-  }
-
-  /**
-   * 重置统计信息
-   */
-  resetStats() {
-    this.stats = { hits: 0, misses: 0, sets: 0, deletes: 0, errors: 0 };
-  }
-
-  /**
-   * 健康检查
-   */
-  async healthCheck() {
-    if (!this.isConnected) {
-      return { healthy: false, message: 'Redis 未连接' };
-    }
-
-    try {
-      const testKey = this._getKey('health:check');
-      await this.client.set(testKey, 'OK');
-      const value = await this.client.get(testKey);
-      await this.client.del(testKey);
-
-      return {
-        healthy: value === 'OK',
-        message: 'Redis 健康检查通过',
-      };
-    } catch (error) {
-      Logger.error('Redis 健康检查失败:', { error: error.message });
-      return { healthy: false, message: error.message };
-    }
-  }
-
-  /**
-   * 断开连接
-   */
-  async disconnect() {
-    if (this.client && this.isConnected) {
-      try {
-        await this.client.quit();
-        Logger.info('Redis 连接已关闭');
-      } catch (error) {
-        Logger.error('Redis 断开连接失败:', { error: error.message });
-        await this.client.disconnect();
-      }
-    }
-    this.isConnected = false;
-  }
-}
-
-// 单例实例
-let redisServiceInstance = null;
-
-/**
- * 初始化 Redis 服务
- */
-export async function initRedisService(config) {
-  if (redisServiceInstance) {
-    Logger.warn('Redis 服务已初始化');
-    return redisServiceInstance;
-  }
-
-  redisServiceInstance = new RedisService(config);
-  await redisServiceInstance.connect();
-  return redisServiceInstance;
-}
-
-/**
- * 获取 Redis 服务实例
- */
-export function getRedisService() {
-  if (!redisServiceInstance) {
-    throw new Error('Redis 服务未初始化，请先调用 initRedisService()');
-  }
-  return redisServiceInstance;
-}
-
-export default RedisService;