@chongyan/autospec 1.0.1

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

@@ -0,0 +1,865 @@
+/**
+ * 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;