@chongyan/autospec 1.0.2 → 1.0.4

package/plugins/hooks/lib/detection-pattern-loader.js

@@ -1,865 +0,0 @@
-/**
- * Detection Pattern Loader
- *
- * 加载和管理检测模式配置
- *
- * 此文件是 hooks 模块的一部分，可独立运行于目标项目中。
- */
-
-import fs from 'fs';
-import path from 'path';
-
-// 动态加载 js-yaml（延迟加载，避免 top-level await 导致模块加载失败）
-let yaml = null;
-let yamlLoadAttempted = false;
-
-/**
- * 确保 js-yaml 已加载（延迟加载）
- * 将 top-level await 改为函数内动态导入，避免模块初始化失败
- */
-async function ensureYaml() {
-  if (yamlLoadAttempted) return yaml;
-  yamlLoadAttempted = true;
-  try {
-    yaml = await import('js-yaml');
-  } catch (e) {
-    // js-yaml 不可用，使用降级方案 parseYamlSimple / dumpYamlSimple
-  }
-  return yaml;
-}
-
-/**
- * 简单的 YAML 解析器（降级方案）
- * 支持多层嵌套、数组、行内数组等基本结构
- */
-function parseYamlSimple(content) {
-  const lines = content.split('\n');
-  const result = {};
-
-  const stack = [{ obj: result, indent: -1, isArrayItem: false }];
-
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) continue;
-
-    const indent = line.search(/\S/);
-
-    while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
-      stack.pop();
-    }
-
-    const top = stack[stack.length - 1];
-    let current = top.obj;
-
-    if (trimmed.startsWith('- ')) {
-      const itemStr = trimmed.substring(2).trim();
-
-      if (!Array.isArray(current)) {
-        const parent = stack[stack.length - 2]?.obj;
-        if (parent && typeof parent === 'object') {
-          const keys = Object.keys(parent);
-          const lastKey = keys[keys.length - 1];
-          if (lastKey && typeof parent[lastKey] === 'object' && !Array.isArray(parent[lastKey])) {
-            const existing = parent[lastKey];
-            if (Object.keys(existing).length === 0) {
-              parent[lastKey] = [];
-              current = parent[lastKey];
-              stack[stack.length - 1] = { obj: current, indent: top.indent, isArrayItem: true };
-            }
-          }
-        }
-      }
-
-      if (Array.isArray(current)) {
-        const colonIndex = itemStr.indexOf(':');
-        if (colonIndex > 0) {
-          const item = {};
-          const key = itemStr.substring(0, colonIndex).trim();
-          let value = itemStr.substring(colonIndex + 1).trim();
-          item[key] = parseYamlValue(value);
-          current.push(item);
-          stack.push({ obj: item, indent, isArrayItem: true });
-        } else {
-          current.push(parseYamlValue(itemStr));
-        }
-      }
-      continue;
-    }
-
-    const colonIndex = trimmed.indexOf(':');
-    if (colonIndex > 0) {
-      const key = trimmed.substring(0, colonIndex).trim();
-      let value = trimmed.substring(colonIndex + 1).trim();
-
-      if (value.startsWith('[') && value.endsWith(']')) {
-        current[key] = parseInlineArray(value);
-      } else if (value) {
-        current[key] = parseYamlValue(value);
-      } else {
-        current[key] = {};
-        stack.push({ obj: current[key], indent, isArrayItem: false });
-      }
-    }
-  }
-
-  return result;
-}
-
-/**
- * 解析行内数组
- */
-function parseInlineArray(value) {
-  const inner = value.slice(1, -1).trim();
-  if (!inner) return [];
-
-  const items = [];
-  let current = '';
-  let depth = 0;
-
-  for (const char of inner) {
-    if (char === '[') depth++;
-    if (char === ']') depth--;
-    if (char === ',' && depth === 0) {
-      items.push(parseYamlValue(current.trim()));
-      current = '';
-    } else {
-      current += char;
-    }
-  }
-  if (current.trim()) {
-    items.push(parseYamlValue(current.trim()));
-  }
-
-  return items;
-}
-
-/**
- * 解析 YAML 值
- */
-function parseYamlValue(value) {
-  if (!value) return value;
-
-  if (value.startsWith('[') && value.endsWith(']')) {
-    return parseInlineArray(value);
-  }
-
-  if ((value.startsWith('"') && value.endsWith('"')) ||
-      (value.startsWith("'") && value.endsWith("'"))) {
-    return value.slice(1, -1);
-  }
-
-  if (value === 'true') return true;
-  if (value === 'false') return false;
-  if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-  if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-
-  return value;
-}
-
-/**
- * 简单的 YAML 序列化（降级方案）
- */
-function dumpYamlSimple(obj, indent = 0) {
-  const spaces = '  '.repeat(indent);
-  let result = '';
-
-  for (const [key, value] of Object.entries(obj)) {
-    if (value === null || value === undefined) continue;
-
-    if (typeof value === 'object' && !Array.isArray(value)) {
-      result += `${spaces}${key}:\n`;
-      result += dumpYamlSimple(value, indent + 1);
-    } else if (Array.isArray(value)) {
-      result += `${spaces}${key}:\n`;
-      for (const item of value) {
-        if (typeof item === 'object' && item !== null) {
-          const entries = Object.entries(item);
-          if (entries.length > 0) {
-            result += `${spaces}  - ${entries[0][0]}: ${serializeValue(entries[0][1])}\n`;
-            for (let i = 1; i < entries.length; i++) {
-              result += `${spaces}    ${entries[i][0]}: ${serializeValue(entries[i][1])}\n`;
-            }
-          }
-        } else {
-          result += `${spaces}  - ${serializeValue(item)}\n`;
-        }
-      }
-    } else {
-      result += `${spaces}${key}: ${serializeValue(value)}\n`;
-    }
-  }
-
-  return result;
-}
-
-/**
- * 序列化 YAML 值
- */
-function serializeValue(value) {
-  if (typeof value === 'string') {
-    if (value.includes(':') || value.includes('#') || value.includes('\n')) {
-      return `"${value}"`;
-    }
-    return value;
-  }
-  if (value === true) return 'true';
-  if (value === false) return 'false';
-  if (value === null) return 'null';
-  return String(value);
-}
-
-/**
- * 解析 YAML 内容（异步版本，推荐使用）
- */
-async function parseYamlAsync(content) {
-  await ensureYaml();
-  if (yaml) {
-    return yaml.load(content);
-  }
-  return parseYamlSimple(content);
-}
-
-/**
- * 解析 YAML 内容（同步版本，用于非 async 上下文）
- */
-function parseYaml(content) {
-  if (yaml) {
-    return yaml.load(content);
-  }
-  return parseYamlSimple(content);
-}
-
-/**
- * 序列化为 YAML（异步版本，推荐使用）
- */
-async function dumpYamlAsync(obj, options = {}) {
-  await ensureYaml();
-  if (yaml) {
-    return yaml.dump(obj, options);
-  }
-  return dumpYamlSimple(obj);
-}
-
-/**
- * 序列化为 YAML（同步版本，用于非 async 上下文）
- */
-function dumpYaml(obj, options = {}) {
-  if (yaml) {
-    return yaml.dump(obj, options);
-  }
-  return dumpYamlSimple(obj);
-}
-
-// ============================================================
-// 内联常量（来自 constants.js，仅保留 hooks 需要的部分）
-// ============================================================
-
-const ENV_DIRS = {
-  ROOT: 'environment',
-  ENV_KNOWLEDGE: 'environment/env-knowledge',
-  MIDDLEWARE: 'environment/env-knowledge/middleware',
-  INFRASTRUCTURE: 'environment/env-knowledge/infrastructure',
-  ENV_VARIABLES: 'environment/env-knowledge/env-variables',
-  COMPONENT_LIB: 'environment/component-lib',
-  COMPONENTS: 'environment/component-lib/components',
-  BEST_PRACTICES: 'environment/component-lib/best-practices',
-  DOMAIN_MODELS: 'environment/component-lib/domain-models',
-  INTEGRATION: 'environment/integration',
-  CI_CD: 'environment/integration/ci-cd',
-  TESTING: 'environment/integration/testing',
-  DEPLOYMENT: 'environment/integration/deployment',
-};
-
-const ENV_FILES = {
-  REGISTRY: 'registry.json',
-  DETECTION_PATTERNS: 'detection-patterns.yaml',
-  ENVIRONMENT_CONTEXT: 'environment-context.json',
-};
-
-// ============================================================
-// 内置检测模式
-// ============================================================
-
-/**
- * 内置检测模式
- * 当项目没有自定义模式时使用
- */
-const BUILTIN_PATTERNS = {
-  apiVersion: 'autospec/v1',
-  kind: 'DetectionPatterns',
-  meta: {
-    name: 'builtin-patterns',
-    version: '1.0.0',
-    source: 'framework',
-  },
-  spec: {
-    middleware: {
-      mysql: {
-        dependencies: [
-          { pattern: 'mysql2', packageManager: 'npm' },
-          { pattern: 'pymysql', packageManager: 'pip' },
-          { pattern: 'mysql-connector-python', packageManager: 'pip' },
-          { pattern: 'mysql-connector-java', packageManager: 'maven' },
-        ],
-        codePatterns: [
-          { pattern: 'createPool\\s*\\(', language: 'javascript', confidence: 0.9 },
-          { pattern: 'mysql\\.connector', language: 'python', confidence: 0.85 },
-          { pattern: 'mysql2/promise', language: 'javascript', confidence: 0.95 },
-          { pattern: 'pymysql\\.connect', language: 'python', confidence: 0.95 },
-          { pattern: 'com\\.mysql\\.cj', language: 'java', confidence: 0.9 },
-        ],
-        envVarPatterns: [
-          { pattern: 'MYSQL_\\w+', extract: true },
-        ],
-        filePatterns: ['**/*.py', '**/*.js', '**/*.ts', '**/*.java'],
-        knowledgeTemplate: 'middleware/mysql.yaml',
-      },
-      redis: {
-        dependencies: [
-          { pattern: 'ioredis', packageManager: 'npm' },
-          { pattern: 'redis', packageManager: 'npm' },
-          { pattern: 'redis-py', packageManager: 'pip' },
-          { pattern: 'redis', packageManager: 'pip' },
-        ],
-        codePatterns: [
-          { pattern: 'new Redis\\s*\\(', language: 'javascript', confidence: 0.9 },
-          { pattern: 'redis\\.Redis', language: 'python', confidence: 0.85 },
-          { pattern: 'createClient\\s*\\(', language: 'javascript', confidence: 0.85 },
-          { pattern: 'ioredis', language: 'javascript', confidence: 0.95 },
-        ],
-        envVarPatterns: [
-          { pattern: 'REDIS_\\w+', extract: true },
-        ],
-        filePatterns: ['**/*.py', '**/*.js', '**/*.ts', '**/*.java'],
-        knowledgeTemplate: 'middleware/redis.yaml',
-      },
-      kafka: {
-        dependencies: [
-          { pattern: 'kafkajs', packageManager: 'npm' },
-          { pattern: 'confluent-kafka', packageManager: 'pip' },
-          { pattern: 'kafka-python', packageManager: 'pip' },
-          { pattern: 'org.apache.kafka', packageManager: 'maven' },
-        ],
-        codePatterns: [
-          { pattern: 'Kafka\\(|KafkaJS', language: 'javascript', confidence: 0.9 },
-          { pattern: 'KafkaConsumer|KafkaProducer', language: 'python', confidence: 0.9 },
-          { pattern: 'KafkaProducer|KafkaConsumer', language: 'java', confidence: 0.95 },
-        ],
-        envVarPatterns: [
-          { pattern: 'KAFKA_\\w+', extract: true },
-        ],
-        filePatterns: ['**/*.py', '**/*.js', '**/*.ts', '**/*.java'],
-        knowledgeTemplate: 'middleware/kafka.yaml',
-      },
-      mongodb: {
-        dependencies: [
-          { pattern: 'mongoose', packageManager: 'npm' },
-          { pattern: 'mongodb', packageManager: 'npm' },
-          { pattern: 'pymongo', packageManager: 'pip' },
-        ],
-        codePatterns: [
-          { pattern: 'mongoose\\.connect', language: 'javascript', confidence: 0.95 },
-          { pattern: 'MongoClient', language: 'javascript', confidence: 0.9 },
-          { pattern: 'pymongo\\.MongoClient', language: 'python', confidence: 0.95 },
-        ],
-        envVarPatterns: [
-          { pattern: 'MONGO\\w*', extract: true },
-        ],
-        filePatterns: ['**/*.py', '**/*.js', '**/*.ts', '**/*.java'],
-        knowledgeTemplate: 'middleware/mongodb.yaml',
-      },
-      elasticsearch: {
-        dependencies: [
-          { pattern: '@elastic/elasticsearch', packageManager: 'npm' },
-          { pattern: 'elasticsearch', packageManager: 'pip' },
-        ],
-        codePatterns: [
-          { pattern: 'Client\\s*\\(', language: 'javascript', confidence: 0.7 },
-          { pattern: 'Elasticsearch\\s*\\(', language: 'python', confidence: 0.85 },
-          { pattern: '@elastic/elasticsearch', language: 'javascript', confidence: 0.95 },
-        ],
-        envVarPatterns: [
-          { pattern: 'ELASTIC\\w*', extract: true },
-        ],
-        filePatterns: ['**/*.py', '**/*.js', '**/*.ts', '**/*.java'],
-        knowledgeTemplate: 'middleware/elasticsearch.yaml',
-      },
-      postgresql: {
-        dependencies: [
-          { pattern: 'pg', packageManager: 'npm' },
-          { pattern: 'psycopg2', packageManager: 'pip' },
-          { pattern: 'psycopg', packageManager: 'pip' },
-          { pattern: 'org.postgresql', packageManager: 'maven' },
-        ],
-        codePatterns: [
-          { pattern: 'pg\\.Pool|pg\\.Client', language: 'javascript', confidence: 0.9 },
-          { pattern: 'psycopg2\\.connect', language: 'python', confidence: 0.95 },
-          { pattern: 'postgresql://', language: 'any', confidence: 0.8 },
-        ],
-        envVarPatterns: [
-          { pattern: 'POSTGRES_\\w+|PG_\\w+', extract: true },
-        ],
-        filePatterns: ['**/*.py', '**/*.js', '**/*.ts', '**/*.java'],
-        knowledgeTemplate: 'middleware/postgresql.yaml',
-      },
-      rabbitmq: {
-        dependencies: [
-          { pattern: 'amqplib', packageManager: 'npm' },
-          { pattern: 'pika', packageManager: 'pip' },
-          { pattern: 'rabbitmq', packageManager: 'pip' },
-        ],
-        codePatterns: [
-          { pattern: 'amqp\\.connect', language: 'javascript', confidence: 0.9 },
-          { pattern: 'pika\\.BlockingConnection', language: 'python', confidence: 0.95 },
-          { pattern: 'amqplib', language: 'javascript', confidence: 0.9 },
-        ],
-        envVarPatterns: [
-          { pattern: 'RABBITMQ_\\w+|AMQP_\\w+', extract: true },
-        ],
-        filePatterns: ['**/*.py', '**/*.js', '**/*.ts', '**/*.java'],
-        knowledgeTemplate: 'middleware/rabbitmq.yaml',
-      },
-    },
-    components: {
-      // 通用组件模式，可被组织配置覆盖
-    },
-    bestPractices: {
-      'connection-pool': {
-        pattern: 'poolSize|connectionLimit|maxConnections|pool_size',
-        description: '连接池配置检测',
-        appliesTo: ['mysql', 'redis', 'postgresql', 'mongodb'],
-      },
-      'error-handling': {
-        pattern: 'try\\s*\\{|catch\\s*\\(|\\.catch\\s*\\(',
-        description: '错误处理模式',
-        appliesTo: ['*'],
-      },
-      'retry-mechanism': {
-        pattern: 'retry|maxRetry|retryTimes|backoff',
-        description: '重试机制',
-        appliesTo: ['*'],
-      },
-    },
-  },
-};
-
-/**
- * 检测模式加载器
- */
-export class PatternLoader {
-  constructor(autospecDir) {
-    this.autospecDir = autospecDir;
-    this.envDir = path.join(autospecDir, ENV_DIRS.ROOT);
-    this.patternsPath = path.join(this.envDir, ENV_FILES.DETECTION_PATTERNS);
-    this.patterns = null;
-  }
-
-  /**
-   * 加载检测模式
-   * 合并内置模式和组织自定义模式
-   */
-  load() {
-    // 1. 从内置模式开始
-    let patterns = JSON.parse(JSON.stringify(BUILTIN_PATTERNS));
-
-    // 2. 加载组织自定义模式（如果存在）
-    // 注意：同步版本会使用降级方案 parseYamlSimple
-    const orgPatterns = this.loadOrganizationPatterns();
-
-    if (orgPatterns) {
-      // 深度合并：组织模式可覆盖内置模式
-      patterns = this.mergePatterns(patterns, orgPatterns);
-    }
-
-    this.patterns = patterns;
-    return this.patterns;
-  }
-
-  /**
-   * 异步加载检测模式（推荐使用）
-   * 合并内置模式和组织自定义模式
-   * 会尝试加载 js-yaml 以获得更好的 YAML 解析能力
-   */
-  async loadAsync() {
-    // 确保 js-yaml 已加载（如果可用）
-    await ensureYaml();
-
-    // 1. 从内置模式开始
-    let patterns = JSON.parse(JSON.stringify(BUILTIN_PATTERNS));
-
-    // 2. 加载组织自定义模式（如果存在）
-    const orgPatterns = await this.loadOrganizationPatternsAsync();
-
-    if (orgPatterns) {
-      // 深度合并：组织模式可覆盖内置模式
-      patterns = this.mergePatterns(patterns, orgPatterns);
-    }
-
-    this.patterns = patterns;
-    return this.patterns;
-  }
-
-  /**
-   * 加载组织自定义模式（同步版本，使用降级方案）
-   */
-  loadOrganizationPatterns() {
-    if (!fs.existsSync(this.patternsPath)) {
-      return null;
-    }
-
-    try {
-      const content = fs.readFileSync(this.patternsPath, 'utf-8');
-      return parseYaml(content);  // 同步版本，可能使用降级方案
-    } catch (e) {
-      console.warn('Failed to load organization patterns:', e.message);
-      return null;
-    }
-  }
-
-  /**
-   * 加载组织自定义模式（异步版本，推荐使用）
-   */
-  async loadOrganizationPatternsAsync() {
-    if (!fs.existsSync(this.patternsPath)) {
-      return null;
-    }
-
-    try {
-      const content = fs.readFileSync(this.patternsPath, 'utf-8');
-      return await parseYamlAsync(content);  // 异步版本，尝试使用 js-yaml
-    } catch (e) {
-      console.warn('Failed to load organization patterns:', e.message);
-      return null;
-    }
-  }
-
-  /**
-   * 深度合并模式
-   */
-  mergePatterns(base, override) {
-    const result = { ...base };
-
-    if (override.metadata) {
-      result.metadata = { ...base.metadata, ...override.metadata };
-    }
-
-    if (override.spec) {
-      result.spec = { ...base.spec };
-
-      // 合并中间件模式
-      if (override.spec.middleware) {
-        result.spec.middleware = { ...base.spec.middleware, ...override.spec.middleware };
-      }
-
-      // 合并组件模式
-      if (override.spec.components) {
-        result.spec.components = { ...base.spec.components, ...override.spec.components };
-      }
-
-      // 合并最佳实践模式
-      if (override.spec.bestPractices) {
-        result.spec.bestPractices = { ...base.spec.bestPractices, ...override.spec.bestPractices };
-      }
-    }
-
-    return result;
-  }
-
-  /**
-   * 获取中间件检测模式
-   */
-  getMiddlewarePatterns() {
-    if (!this.patterns) {
-      this.load();
-    }
-    return this.patterns.spec.middleware || {};
-  }
-
-  /**
-   * 获取特定中间件的检测模式
-   */
-  getMiddlewarePattern(name) {
-    const patterns = this.getMiddlewarePatterns();
-    return patterns[name] || null;
-  }
-
-  /**
-   * 获取组件检测模式
-   */
-  getComponentPatterns() {
-    if (!this.patterns) {
-      this.load();
-    }
-    return this.patterns.spec.components || {};
-  }
-
-  /**
-   * 获取最佳实践检测模式
-   */
-  getBestPracticePatterns() {
-    if (!this.patterns) {
-      this.load();
-    }
-    return this.patterns.spec.bestPractices || {};
-  }
-
-  /**
-   * 获取所有检测模式
-   */
-  getAllPatterns() {
-    if (!this.patterns) {
-      this.load();
-    }
-    return this.patterns;
-  }
-
-  /**
-   * 添加自定义中间件模式
-   */
-  addMiddlewarePattern(name, pattern) {
-    if (!this.patterns) {
-      this.load();
-    }
-
-    if (!this.patterns.spec.middleware) {
-      this.patterns.spec.middleware = {};
-    }
-
-    this.patterns.spec.middleware[name] = pattern;
-    this.saveOrganizationPatterns();
-  }
-
-  /**
-   * 添加自定义组件模式
-   */
-  addComponentPattern(name, pattern) {
-    if (!this.patterns) {
-      this.load();
-    }
-
-    if (!this.patterns.spec.components) {
-      this.patterns.spec.components = {};
-    }
-
-    this.patterns.spec.components[name] = pattern;
-    this.saveOrganizationPatterns();
-  }
-
-  /**
-   * 保存组织自定义模式
-   */
-  saveOrganizationPatterns() {
-    if (!fs.existsSync(this.envDir)) {
-      fs.mkdirSync(this.envDir, { recursive: true });
-    }
-
-    // 只保存非内置的模式（标记为组织自定义）
-    const orgPatterns = {
-      apiVersion: 'autospec/v1',
-      kind: 'DetectionPatterns',
-      meta: {
-        name: 'organization-patterns',
-        version: '1.0.0',
-        source: 'organization',
-      },
-      spec: {
-        middleware: {},
-        components: {},
-        bestPractices: {},
-      },
-    };
-
-    // 过滤出非内置的模式
-    const builtinMiddleware = Object.keys(BUILTIN_PATTERNS.spec.middleware);
-    for (const [name, pattern] of Object.entries(this.patterns.spec.middleware || {})) {
-      if (!builtinMiddleware.includes(name) || this.isPatternModified(name, pattern, 'middleware')) {
-        orgPatterns.spec.middleware[name] = pattern;
-      }
-    }
-
-    for (const [name, pattern] of Object.entries(this.patterns.spec.components || {})) {
-      orgPatterns.spec.components[name] = pattern;
-    }
-
-    for (const [name, pattern] of Object.entries(this.patterns.spec.bestPractices || {})) {
-      if (this.isPatternModified(name, pattern, 'bestPractices')) {
-        orgPatterns.spec.bestPractices[name] = pattern;
-      }
-    }
-
-    fs.writeFileSync(this.patternsPath, dumpYaml(orgPatterns, { lineWidth: -1 }));
-  }
-
-  /**
-   * 检查模式是否被修改
-   */
-  isPatternModified(name, pattern, category) {
-    const builtin = BUILTIN_PATTERNS.spec[category]?.[name];
-    if (!builtin) return true;
-    return JSON.stringify(builtin) !== JSON.stringify(pattern);
-  }
-
-  /**
-   * 验证模式配置
-   */
-  validatePattern(pattern) {
-    const errors = [];
-
-    if (!pattern.dependencies && !pattern.codePatterns && !pattern.envVarPatterns) {
-      errors.push('至少需要定义 dependencies、codePatterns 或 envVarPatterns 之一');
-    }
-
-    if (pattern.dependencies) {
-      for (const dep of pattern.dependencies) {
-        if (!dep.pattern) {
-          errors.push('dependency 必须包含 pattern 字段');
-        }
-      }
-    }
-
-    if (pattern.codePatterns) {
-      for (const cp of pattern.codePatterns) {
-        if (!cp.pattern) {
-          errors.push('codePattern 必须包含 pattern 字段');
-        }
-        // 验证正则表达式
-        try {
-          new RegExp(cp.pattern);
-        } catch (e) {
-          errors.push(`无效的正则表达式: ${cp.pattern}`);
-        }
-      }
-    }
-
-    return {
-      valid: errors.length === 0,
-      errors,
-    };
-  }
-
-  /**
-   * 从依赖文件检测中间件
-   * @param {string} packageJsonPath - package.json 路径
-   * @param {string} requirementsPath - requirements.txt 路径
-   * @param {string} pomXmlPath - pom.xml 路径
-   */
-  detectFromDependencies(packageJsonPath, requirementsPath, pomXmlPath) {
-    const detected = [];
-    const patterns = this.getMiddlewarePatterns();
-
-    // 检测 npm 依赖
-    if (packageJsonPath && fs.existsSync(packageJsonPath)) {
-      try {
-        const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-
-        for (const [depName] of Object.entries(deps)) {
-          for (const [mwName, mwPattern] of Object.entries(patterns)) {
-            if (mwPattern.dependencies) {
-              for (const dep of mwPattern.dependencies) {
-                if (dep.packageManager === 'npm' && this.matchDependency(dep.pattern, depName)) {
-                  detected.push({
-                    name: mwName,
-                    source: 'npm',
-                    dependency: depName,
-                    confidence: 0.9,
-                  });
-                }
-              }
-            }
-          }
-        }
-      } catch (e) {
-        // 忽略解析错误
-      }
-    }
-
-    // 检测 pip 依赖
-    if (requirementsPath && fs.existsSync(requirementsPath)) {
-      try {
-        const content = fs.readFileSync(requirementsPath, 'utf-8');
-        const lines = content.split('\n');
-
-        for (const line of lines) {
-          const depName = line.split(/[=<>]/)[0].trim();
-          if (!depName || depName.startsWith('#')) continue;
-
-          for (const [mwName, mwPattern] of Object.entries(patterns)) {
-            if (mwPattern.dependencies) {
-              for (const dep of mwPattern.dependencies) {
-                if (dep.packageManager === 'pip' && this.matchDependency(dep.pattern, depName)) {
-                  detected.push({
-                    name: mwName,
-                    source: 'pip',
-                    dependency: depName,
-                    confidence: 0.9,
-                  });
-                }
-              }
-            }
-          }
-        }
-      } catch (e) {
-        // 忽略解析错误
-      }
-    }
-
-    // 检测 maven 依赖
-    if (pomXmlPath && fs.existsSync(pomXmlPath)) {
-      try {
-        const content = fs.readFileSync(pomXmlPath, 'utf-8');
-        // 简单的 XML 解析，提取 groupId:artifactId
-        const depMatches = content.matchAll(/<dependency>[\s\S]*?<groupId>([^<]+)<\/groupId>[\s\S]*?<artifactId>([^<]+)<\/artifactId>[\s\S]*?<\/dependency>/g);
-
-        for (const match of depMatches) {
-          const depName = `${match[1]}:${match[2]}`;
-
-          for (const [mwName, mwPattern] of Object.entries(patterns)) {
-            if (mwPattern.dependencies) {
-              for (const dep of mwPattern.dependencies) {
-                if (dep.packageManager === 'maven' && this.matchDependency(dep.pattern, depName)) {
-                  detected.push({
-                    name: mwName,
-                    source: 'maven',
-                    dependency: depName,
-                    confidence: 0.9,
-                  });
-                }
-              }
-            }
-          }
-        }
-      } catch (e) {
-        // 忽略解析错误
-      }
-    }
-
-    // 去重
-    const unique = [];
-    const seen = new Set();
-    for (const item of detected) {
-      const key = item.name;
-      if (!seen.has(key)) {
-        seen.add(key);
-        unique.push(item);
-      }
-    }
-
-    return unique;
-  }
-
-  /**
-   * 匹配依赖名称
-   */
-  matchDependency(pattern, depName) {
-    if (pattern.startsWith('^') || pattern.includes('*')) {
-      // 简单的通配符匹配
-      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-      return regex.test(depName);
-    }
-    return depName === pattern || depName.includes(pattern);
-  }
-}
-
-export default PatternLoader;