@chongyan/autospec 1.0.1

package/plugins/hooks/lib/environment-evolver.js

@@ -0,0 +1,564 @@
+/**
+ * Environment Knowledge Evolver
+ *
+ * 环境知识进化器，从实践中发现和沉淀环境知识
+ */
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { ENV_DIRS, KNOWLEDGE_ZONES, KNOWLEDGE_TYPES } from '../../constants.js';
+import { PatternLoader } from './detection-pattern-loader.js';
+import { EnvironmentRegistry } from './environment-registry.js';
+import {
+  scanCodePatterns,
+  scanEnvVarPatterns,
+  scanDependencies,
+  discoverSourceDirs,
+} from './source-code-scanner.js';
+
+// 简单的 UUID 生成函数
+function uuidv4() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+    const r = Math.random() * 16 | 0;
+    const v = c === 'x' ? r : (r & 0x3 | 0x8);
+    return v.toString(16);
+  });
+}
+
+/**
+ * 环境知识进化器
+ */
+export class EnvironmentEvolver {
+  constructor(projectRoot, config = {}) {
+    this.projectRoot = projectRoot;
+    this.config = config;
+    this.autospecDir = path.join(projectRoot, '.autospec');
+    this.envDir = path.join(this.autospecDir, ENV_DIRS.ROOT);
+    this.evolutionDir = path.join(this.autospecDir, 'evolution');
+    this.practiceLogDir = path.join(this.evolutionDir, 'practice-log');
+    this.proposalsDir = path.join(this.evolutionDir, 'proposals');
+
+    // 使用可配置的检测模式
+    this.patternLoader = new PatternLoader(this.autospecDir);
+    this.patternLoader.load();
+  }
+
+  /**
+   * 检测新的中间件使用模式
+   */
+  async detectNewMiddlewarePatterns() {
+    const patterns = [];
+
+    // 1. 扫描代码中的中间件使用
+    const codePatterns = await this.scanMiddlewareInCode();
+
+    // 2. 与现有知识库对比
+    const existingKnowledge = this.loadExistingMiddlewareKnowledge();
+
+    for (const pattern of codePatterns) {
+      const exists = existingKnowledge.some(
+        (k) => k.metadata?.name === pattern.name || k.meta?.name === pattern.name
+      );
+
+      if (!exists) {
+        patterns.push({
+          type: 'new-middleware',
+          name: pattern.name,
+          evidence: pattern.evidence,
+          suggestedConfig: pattern.suggestedConfig,
+          zone: KNOWLEDGE_ZONES.CONTROLLED, // 受控区，需要人工批准
+        });
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * 检测新的组件使用模式
+   */
+  async detectNewComponentPatterns() {
+    const patterns = [];
+
+    // 1. 扫描 practice-log 中的模式
+    const practiceLogs = this.loadPracticeLogs();
+
+    // 2. 识别重复出现的使用模式
+    const usagePatterns = this.extractUsagePatterns(practiceLogs);
+
+    // 3. 检查是否在组件库中
+    const existingComponents = this.loadExistingComponents();
+
+    for (const pattern of usagePatterns) {
+      const count = this.countPatternOccurrences(practiceLogs, pattern);
+
+      if (count >= 3) {
+        // 同类问题出现 3 次
+        const exists = existingComponents.some(
+          (c) => c.metadata?.name === pattern.name || c.meta?.name === pattern.name
+        );
+
+        if (!exists) {
+          patterns.push({
+            type: 'new-component',
+            name: pattern.name,
+            evidence: pattern.evidence,
+            occurrences: count,
+            suggestedDefinition: pattern.suggestedDefinition,
+            zone: KNOWLEDGE_ZONES.FREE, // 自由区，可自动进化
+          });
+        }
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * 扫描代码中的中间件使用
+   */
+  async scanMiddlewareInCode() {
+    const patterns = [];
+
+    // 从 PatternLoader 获取检测模式
+    const middlewarePatterns = this.patternLoader.getMiddlewarePatterns();
+
+    // 获取源码目录
+    const sourceDirs = this.discoverSourceDirectories();
+
+    // 扫描项目文件
+    for (const [name, middleware] of Object.entries(middlewarePatterns)) {
+      const evidence = await this.findMiddlewareEvidence(name, middleware, sourceDirs);
+
+      if (evidence.length > 0) {
+        patterns.push({
+          name: name,
+          evidence: evidence,
+          suggestedConfig: this.generateMiddlewareConfigSuggestion(name, middleware, evidence),
+        });
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * 发现源码目录 - 使用公共模块
+   */
+  discoverSourceDirectories() {
+    return discoverSourceDirs(this.projectRoot, this.config);
+  }
+
+  /**
+   * 查找中间件使用证据
+   */
+  async findMiddlewareEvidence(name, middleware, sourceDirs) {
+    const evidence = [];
+
+    // 如果没有源码目录，使用旧逻辑扫描 src/
+    if (sourceDirs.length === 0) {
+      const srcDir = path.join(this.projectRoot, 'src');
+      if (fs.existsSync(srcDir)) {
+        sourceDirs = [{ path: 'src', type: 'unknown', techStack: 'Unknown' }];
+      }
+    }
+
+    // 扫描每个源码目录
+    for (const dir of sourceDirs) {
+      const dirPath = path.join(this.projectRoot, dir.path);
+      if (!fs.existsSync(dirPath)) continue;
+
+      // 扫描代码模式
+      if (middleware.codePatterns) {
+        const codeEvidence = this.scanCodePatterns(dirPath, middleware.codePatterns);
+        evidence.push(...codeEvidence);
+      }
+
+      // 扫描环境变量模式
+      if (middleware.envVarPatterns) {
+        const envEvidence = this.scanEnvVarPatterns(dirPath, middleware.envVarPatterns);
+        evidence.push(...envEvidence);
+      }
+    }
+
+    // 从依赖文件检测
+    if (middleware.dependencies) {
+      const depEvidence = this.scanDependencies(middleware.dependencies);
+      evidence.push(...depEvidence);
+    }
+
+    return evidence.slice(0, 10); // 最多返回 10 条证据
+  }
+
+  /**
+   * 扫描代码模式 - 使用公共模块
+   */
+  scanCodePatterns(dirPath, codePatterns) {
+    return scanCodePatterns(dirPath, codePatterns, { maxDepth: 4 }, this.projectRoot);
+  }
+
+  /**
+   * 扫描环境变量模式 - 使用公共模块
+   */
+  scanEnvVarPatterns(dirPath, envVarPatterns) {
+    return scanEnvVarPatterns(dirPath, envVarPatterns, { maxDepth: 4 }, this.projectRoot);
+  }
+
+  /**
+   * 扫描依赖文件 - 使用公共模块
+   */
+  scanDependencies(dependencies) {
+    return scanDependencies(this.projectRoot, dependencies);
+  }
+
+  /**
+   * 生成中间件配置建议
+   */
+  generateMiddlewareConfigSuggestion(name, middleware, evidence) {
+    // 从证据中提取环境变量
+    const envVars = new Set();
+    for (const e of evidence) {
+      if (e.type === 'env-var' && e.envVars) {
+        for (const v of e.envVars) {
+          envVars.add(v);
+        }
+      }
+    }
+
+    return {
+      apiVersion: 'autospec/v1',
+      kind: KNOWLEDGE_TYPES.MIDDLEWARE,
+      meta: {
+        name: name,
+        version: '1.0',
+        autoGenerated: true,
+        generatedAt: new Date().toISOString(),
+      },
+      spec: {
+        type: this.inferMiddlewareType(name),
+        connection: {
+          template: `# 请补充 ${name} 连接模板`,
+          requiredEnvVars: [...envVars],
+          detectedEnvVars: [...envVars],
+        },
+        bestPractices: middleware.bestPractices || [],
+        antiPatterns: middleware.antiPatterns || [],
+        detectionSource: {
+          patterns: middleware.codePatterns?.map(cp => cp.pattern) || [],
+          evidence: evidence.slice(0, 5),
+        },
+      },
+    };
+  }
+
+  /**
+   * 推断中间件类型
+   */
+  inferMiddlewareType(name) {
+    const typeMap = {
+      'mysql': 'relational-database',
+      'postgresql': 'relational-database',
+      'mongodb': 'document-database',
+      'redis': 'cache',
+      'kafka': 'message-queue',
+      'rabbitmq': 'message-queue',
+      'elasticsearch': 'search-engine',
+    };
+    return typeMap[name.toLowerCase()] || 'unknown';
+  }
+
+  /**
+   * 检测并自动激活
+   */
+  async detectAndActivate() {
+    const middlewarePatterns = await this.detectNewMiddlewarePatterns();
+    const componentPatterns = await this.detectNewComponentPatterns();
+
+    const detected = [...middlewarePatterns, ...componentPatterns];
+    const activated = [];
+
+    // 自动注册并激活检测到的知识
+    const registry = new EnvironmentRegistry(this.autospecDir);
+    registry.load();
+
+    for (const item of detected) {
+      // 检查是否已注册
+      const existing = registry.find('middleware', item.name);
+
+      if (!existing) {
+        // 自动注册
+        registry.register('middleware', {
+          name: item.name,
+          path: `env-knowledge/middleware/${item.name}.yaml`,
+          version: '1.0.0',
+          autoDetected: true,
+          detectedAt: new Date().toISOString(),
+          evidence: item.evidence?.slice(0, 3),
+        });
+      }
+
+      // 自动激活
+      if (!registry.isActive('middleware', item.name)) {
+        registry.activate('middleware', item.name);
+        activated.push(item.name);
+      }
+    }
+
+    registry.save();
+
+    return {
+      detected: detected.map(d => d.name),
+      activated,
+    };
+  }
+
+  /**
+   * 加载现有中间件知识
+   */
+  loadExistingMiddlewareKnowledge() {
+    const knowledge = [];
+    const middlewareDir = path.join(this.envDir, 'env-knowledge/middleware');
+
+    if (!fs.existsSync(middlewareDir)) {
+      return knowledge;
+    }
+
+    const files = fs.readdirSync(middlewareDir, { withFileTypes: true });
+
+    for (const file of files) {
+      if (file.isFile() && (file.name.endsWith('.yaml') || file.name.endsWith('.yml'))) {
+        try {
+          const content = fs.readFileSync(path.join(middlewareDir, file.name), 'utf-8');
+          knowledge.push(yaml.load(content));
+        } catch (e) {
+          // 忽略解析错误
+        }
+      }
+    }
+
+    return knowledge;
+  }
+
+  /**
+   * 加载现有组件
+   */
+  loadExistingComponents() {
+    const components = [];
+    const componentsDir = path.join(this.envDir, 'component-lib/components');
+
+    if (!fs.existsSync(componentsDir)) {
+      return components;
+    }
+
+    const dirs = fs.readdirSync(componentsDir, { withFileTypes: true });
+
+    for (const dir of dirs) {
+      if (dir.isDirectory()) {
+        const componentFile = path.join(componentsDir, dir.name, 'component.yaml');
+        if (fs.existsSync(componentFile)) {
+          try {
+            const content = fs.readFileSync(componentFile, 'utf-8');
+            components.push(yaml.load(content));
+          } catch (e) {
+            // 忽略解析错误
+          }
+        }
+      }
+    }
+
+    return components;
+  }
+
+  /**
+   * 加载实践日志
+   */
+  loadPracticeLogs() {
+    const logs = [];
+
+    if (!fs.existsSync(this.practiceLogDir)) {
+      return logs;
+    }
+
+    const files = fs.readdirSync(this.practiceLogDir, { withFileTypes: true });
+
+    for (const file of files) {
+      if (file.isFile() && file.name.endsWith('.md')) {
+        try {
+          const content = fs.readFileSync(path.join(this.practiceLogDir, file.name), 'utf-8');
+          logs.push({
+            file: file.name,
+            content: content,
+          });
+        } catch (e) {
+          // 忽略读取错误
+        }
+      }
+    }
+
+    return logs;
+  }
+
+  /**
+   * 从实践日志提取使用模式
+   */
+  extractUsagePatterns(logs) {
+    const patterns = [];
+
+    // 简单的模式提取逻辑
+    for (const log of logs) {
+      // 查找重复的代码模式或配置模式
+      const codeBlocks = log.content.match(/```[\s\S]*?```/g) || [];
+
+      for (const block of codeBlocks) {
+        // 提取关键模式
+        const matches = block.match(/(?:import|require|from)\s+['"]([^'"]+)['"]/g);
+        if (matches) {
+          for (const match of matches) {
+            const moduleName = match.match(/['"]([^'"]+)['"]/)?.[1];
+            if (moduleName && !moduleName.startsWith('.')) {
+              patterns.push({
+                name: moduleName,
+                evidence: log.file,
+                suggestedDefinition: null,
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return patterns;
+  }
+
+  /**
+   * 统计模式出现次数
+   */
+  countPatternOccurrences(logs, pattern) {
+    let count = 0;
+
+    for (const log of logs) {
+      if (log.content.includes(pattern.name)) {
+        count++;
+      }
+    }
+
+    return count;
+  }
+
+  /**
+   * 生成进化提案
+   */
+  async generateEvolutionProposals(patterns) {
+    const proposals = [];
+
+    for (const middleware of patterns.middleware || []) {
+      const proposal = {
+        id: uuidv4(),
+        timestamp: new Date().toISOString(),
+        type: 'environment-knowledge',
+        subType: 'middleware',
+        action: 'create',
+        zone: middleware.zone,
+        target: `env-knowledge/middleware/${middleware.name}.yaml`,
+        content: yaml.dump(middleware.suggestedConfig, { lineWidth: -1 }),
+        evidence: middleware.evidence,
+        status: middleware.zone === KNOWLEDGE_ZONES.CONTROLLED ? 'pending-approval' : 'pending-validation',
+      };
+
+      proposals.push(proposal);
+    }
+
+    for (const component of patterns.components || []) {
+      const proposal = {
+        id: uuidv4(),
+        timestamp: new Date().toISOString(),
+        type: 'environment-knowledge',
+        subType: 'component',
+        action: 'create',
+        zone: component.zone,
+        target: `component-lib/components/${component.name}/component.yaml`,
+        content: yaml.dump(component.suggestedDefinition || this.generateDefaultComponentConfig(component), { lineWidth: -1 }),
+        evidence: component.evidence,
+        occurrences: component.occurrences,
+        status: component.zone === KNOWLEDGE_ZONES.CONTROLLED ? 'pending-approval' : 'pending-validation',
+      };
+
+      proposals.push(proposal);
+    }
+
+    // 写入提案文件
+    for (const proposal of proposals) {
+      const proposalPath = path.join(this.proposalsDir, `env-${proposal.id}.json`);
+      fs.writeFileSync(proposalPath, JSON.stringify(proposal, null, 2));
+    }
+
+    return proposals;
+  }
+
+  /**
+   * 生成默认组件配置
+   */
+  generateDefaultComponentConfig(component) {
+    return {
+      apiVersion: 'autospec/v1',
+      kind: KNOWLEDGE_TYPES.COMPONENT,
+      meta: {
+        name: component.name,
+        version: '1.0',
+      },
+      spec: {
+        type: 'utility',
+        description: `从实践中发现的 ${component.name} 组件使用模式`,
+        usage: {},
+        configuration: {
+          required: [],
+          optional: [],
+        },
+      },
+    };
+  }
+
+  /**
+   * 执行进化（自由区自动执行）
+   */
+  async executeEvolution(proposal) {
+    if (proposal.zone === KNOWLEDGE_ZONES.CONTROLLED) {
+      throw new Error('受控区进化需要人工批准');
+    }
+
+    const targetPath = path.join(this.envDir, proposal.target);
+    const dir = path.dirname(targetPath);
+
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(targetPath, proposal.content);
+
+    return { success: true, path: targetPath };
+  }
+
+  /**
+   * 执行完整的进化扫描
+   */
+  async runEvolutionScan() {
+    const middlewarePatterns = await this.detectNewMiddlewarePatterns();
+    const componentPatterns = await this.detectNewComponentPatterns();
+
+    const proposals = await this.generateEvolutionProposals({
+      middleware: middlewarePatterns,
+      components: componentPatterns,
+    });
+
+    return {
+      patterns: {
+        middleware: middlewarePatterns,
+        components: componentPatterns,
+      },
+      proposals: proposals,
+    };
+  }
+}
+
+export default EnvironmentEvolver;