@chongyan/autospec 1.0.1

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

@@ -0,0 +1,813 @@
+/**
+ * Environment Knowledge Registry
+ *
+ * 管理环境知识注册表，合并了原 EnvironmentLoader 的功能
+ * 提供知识注册、加载、缓存等完整能力
+ */
+
+import fs from 'fs';
+import path from 'path';
+import yaml from 'js-yaml';
+import { ENV_DIRS, ENV_FILES, DEFAULT_ENV_REGISTRY, KNOWLEDGE_TYPES } from '../../constants.js';
+
+/**
+ * 知识注册表管理器
+ *
+ * 整合功能：
+ * - 注册表管理（register, unregister, activate）
+ * - 知识加载（loadMiddlewareKnowledge, loadComponentKnowledge）
+ * - 缓存机制
+ */
+export class EnvironmentRegistry {
+  constructor(autospecDir) {
+    this.autospecDir = autospecDir;
+    this.envDir = path.join(autospecDir, ENV_DIRS.ROOT);
+    this.registryPath = path.join(this.envDir, ENV_FILES.REGISTRY);
+    this.registry = null;
+    this.cache = new Map(); // 知识缓存
+  }
+
+  // ============================================================
+  // 初始化与基础操作
+  // ============================================================
+
+  /**
+   * 初始化（兼容 EnvironmentLoader）
+   */
+  async initialize() {
+    this.load();
+    return this;
+  }
+
+  /**
+   * 检查环境衔接层是否存在
+   */
+  exists() {
+    return fs.existsSync(this.envDir);
+  }
+
+  /**
+   * 加载注册表
+   */
+  load() {
+    if (!fs.existsSync(this.registryPath)) {
+      this.registry = { ...DEFAULT_ENV_REGISTRY };
+      return this.registry;
+    }
+
+    try {
+      this.registry = JSON.parse(fs.readFileSync(this.registryPath, 'utf-8'));
+      return this.registry;
+    } catch (e) {
+      console.warn('Failed to load registry:', e.message);
+      this.registry = { ...DEFAULT_ENV_REGISTRY };
+      return this.registry;
+    }
+  }
+
+  /**
+   * 获取默认注册表（兼容 EnvironmentLoader）
+   */
+  getDefaultRegistry() {
+    return { ...DEFAULT_ENV_REGISTRY };
+  }
+
+  /**
+   * 保存注册表
+   */
+  save() {
+    if (!fs.existsSync(this.envDir)) {
+      fs.mkdirSync(this.envDir, { recursive: true });
+    }
+
+    this.registry.lastUpdated = new Date().toISOString().split('T')[0];
+    fs.writeFileSync(this.registryPath, JSON.stringify(this.registry, null, 2));
+  }
+
+  /**
+   * 获取注册表
+   */
+  get() {
+    if (!this.registry) {
+      this.load();
+    }
+    return this.registry;
+  }
+
+  /**
+   * 清除缓存
+   */
+  clearCache() {
+    this.cache.clear();
+  }
+
+  // ============================================================
+  // 知识加载（原 EnvironmentLoader 功能）
+  // ============================================================
+
+  /**
+   * 加载中间件知识
+   * @param {string} name - 中间件名称
+   * @returns {Object|null} 中间件知识对象
+   */
+  loadMiddlewareKnowledge(name) {
+    const cacheKey = `middleware:${name}`;
+
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    const entry = this.find('middleware', name);
+    if (!entry) {
+      return null;
+    }
+
+    const knowledgePath = path.join(this.envDir, entry.path);
+    if (!fs.existsSync(knowledgePath)) {
+      return null;
+    }
+
+    try {
+      const knowledge = yaml.load(fs.readFileSync(knowledgePath, 'utf-8'));
+      this.cache.set(cacheKey, knowledge);
+      return knowledge;
+    } catch (e) {
+      console.warn(`Failed to load middleware knowledge ${name}:`, e.message);
+      return null;
+    }
+  }
+
+  /**
+   * 加载组件知识
+   * @param {string} name - 组件名称
+   * @returns {Object|null} 组件知识对象
+   */
+  loadComponentKnowledge(name) {
+    const cacheKey = `component:${name}`;
+
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    const entry = this.find('components', name);
+    if (!entry) {
+      return null;
+    }
+
+    const knowledgePath = path.join(this.envDir, entry.path);
+    if (!fs.existsSync(knowledgePath)) {
+      return null;
+    }
+
+    try {
+      const knowledge = yaml.load(fs.readFileSync(knowledgePath, 'utf-8'));
+      this.cache.set(cacheKey, knowledge);
+      return knowledge;
+    } catch (e) {
+      console.warn(`Failed to load component knowledge ${name}:`, e.message);
+      return null;
+    }
+  }
+
+  /**
+   * 加载集成知识
+   * @param {string} type - 集成类型 (ci_cd, testing, deployment)
+   * @param {string} name - 集成名称
+   * @returns {Object|null} 集成知识对象
+   */
+  loadIntegrationKnowledge(type, name) {
+    const cacheKey = `integration:${type}:${name}`;
+
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey);
+    }
+
+    const typeMap = {
+      ci_cd: 'ci_cd',
+      testing: 'testing',
+      deployment: 'deployment',
+    };
+
+    const list = this.registry.integrationKnowledge?.[typeMap[type]] || [];
+    const entry = list.find((i) => i.name === name);
+
+    if (!entry) {
+      return null;
+    }
+
+    const knowledgePath = path.join(this.envDir, entry.path);
+    if (!fs.existsSync(knowledgePath)) {
+      return null;
+    }
+
+    try {
+      const knowledge = yaml.load(fs.readFileSync(knowledgePath, 'utf-8'));
+      this.cache.set(cacheKey, knowledge);
+      return knowledge;
+    } catch (e) {
+      console.warn(`Failed to load integration knowledge ${type}/${name}:`, e.message);
+      return null;
+    }
+  }
+
+  /**
+   * 获取激活的环境知识
+   * @returns {Object} 包含所有激活知识的对象
+   */
+  getActiveEnvironmentKnowledge() {
+    if (!this.registry) {
+      this.load();
+    }
+
+    const activeEnv = this.registry.activeProfiles?.environment || 'development';
+    const activeComponents = this.registry.activeProfiles?.components || [];
+    const activeCiCd = this.registry.activeProfiles?.ci_cd;
+
+    return {
+      environment: activeEnv,
+      middleware: this.list('middleware')
+        .map((m) => this.loadMiddlewareKnowledge(m.name))
+        .filter(Boolean),
+      components: activeComponents
+        .map((c) => this.loadComponentKnowledge(c))
+        .filter(Boolean),
+      ci_cd: activeCiCd ? this.loadIntegrationKnowledge('ci_cd', activeCiCd) : null,
+    };
+  }
+
+  /**
+   * 获取注入到 skill 的上下文
+   * @returns {Object} 可直接注入到 skill 执行上下文的知识
+   */
+  getInjectionContext() {
+    const knowledge = this.getActiveEnvironmentKnowledge();
+
+    return {
+      // 当前环境
+      activeEnvironment: knowledge.environment,
+
+      // 中间件连接信息模板
+      middlewareTemplates: knowledge.middleware.map((m) => ({
+        name: m.metadata?.name || m.meta?.name,
+        type: m.spec?.type,
+        connectionTemplate: m.spec?.connection?.template,
+        requiredEnvVars: m.spec?.connection?.requiredEnvVars || [],
+        optionalEnvVars: m.spec?.connection?.optionalEnvVars || [],
+        bestPractices: m.spec?.bestPractices || [],
+        antiPatterns: m.spec?.antiPatterns || [],
+      })),
+
+      // 组件使用信息
+      componentUsage: knowledge.components.map((c) => ({
+        name: c.metadata?.name || c.meta?.name,
+        type: c.spec?.type,
+        description: c.spec?.description,
+        usage: c.spec?.usage || {},
+        configuration: c.spec?.configuration || {},
+        checklist: c.spec?.checklist || {},
+        interfaces: c.spec?.interfaces || [],
+      })),
+
+      // CI/CD 集成点
+      integrationHooks: knowledge.ci_cd?.spec?.autospecIntegration || null,
+
+      // 部署门禁
+      deploymentGates: knowledge.ci_cd?.spec?.deploymentGates || [],
+    };
+  }
+
+  // ============================================================
+  // 注册表管理
+  // ============================================================
+
+  /**
+   * 注册知识条目
+   * @param {string} category - 知识类别 (middleware, components, ci_cd, etc.)
+   * @param {Object} entry - 条目信息
+   */
+  register(category, entry) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    const categoryMap = {
+      middleware: 'environmentKnowledge.middleware',
+      infrastructure: 'environmentKnowledge.infrastructure',
+      components: 'componentKnowledge.components',
+      bestPractices: 'componentKnowledge.bestPractices',
+      domainModels: 'componentKnowledge.domainModels',
+      ci_cd: 'integrationKnowledge.ci_cd',
+      testing: 'integrationKnowledge.testing',
+      deployment: 'integrationKnowledge.deployment',
+    };
+
+    const path = categoryMap[category];
+    if (!path) {
+      throw new Error(`Unknown category: ${category}`);
+    }
+
+    const list = this.getNestedProperty(this.registry, path);
+    if (!list) {
+      this.setNestedProperty(this.registry, path, []);
+    }
+
+    const targetList = this.getNestedProperty(this.registry, path);
+    const existingIndex = targetList.findIndex((item) => item.name === entry.name);
+
+    if (existingIndex >= 0) {
+      // 更新现有条目
+      targetList[existingIndex] = { ...targetList[existingIndex], ...entry };
+    } else {
+      // 添加新条目
+      targetList.push(entry);
+    }
+
+    this.save();
+  }
+
+  /**
+   * 注销知识条目
+   * @param {string} category - 知识类别
+   * @param {string} name - 条目名称
+   */
+  unregister(category, name) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    const categoryMap = {
+      middleware: 'environmentKnowledge.middleware',
+      infrastructure: 'environmentKnowledge.infrastructure',
+      components: 'componentKnowledge.components',
+      bestPractices: 'componentKnowledge.bestPractices',
+      domainModels: 'componentKnowledge.domainModels',
+      ci_cd: 'integrationKnowledge.ci_cd',
+      testing: 'integrationKnowledge.testing',
+      deployment: 'integrationKnowledge.deployment',
+    };
+
+    const path = categoryMap[category];
+    if (!path) {
+      throw new Error(`Unknown category: ${category}`);
+    }
+
+    const list = this.getNestedProperty(this.registry, path);
+    if (list) {
+      const index = list.findIndex((item) => item.name === name);
+      if (index >= 0) {
+        list.splice(index, 1);
+        this.save();
+      }
+    }
+  }
+
+  /**
+   * 查找知识条目
+   * @param {string} category - 知识类别
+   * @param {string} name - 条目名称
+   */
+  find(category, name) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    const categoryMap = {
+      middleware: 'environmentKnowledge.middleware',
+      infrastructure: 'environmentKnowledge.infrastructure',
+      components: 'componentKnowledge.components',
+      bestPractices: 'componentKnowledge.bestPractices',
+      domainModels: 'componentKnowledge.domainModels',
+      ci_cd: 'integrationKnowledge.ci_cd',
+      testing: 'integrationKnowledge.testing',
+      deployment: 'integrationKnowledge.deployment',
+    };
+
+    const path = categoryMap[category];
+    if (!path) {
+      return null;
+    }
+
+    const list = this.getNestedProperty(this.registry, path);
+    return list ? list.find((item) => item.name === name) : null;
+  }
+
+  /**
+   * 列出某类别所有条目
+   * @param {string} category - 知识类别
+   */
+  list(category) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    const categoryMap = {
+      middleware: 'environmentKnowledge.middleware',
+      infrastructure: 'environmentKnowledge.infrastructure',
+      components: 'componentKnowledge.components',
+      bestPractices: 'componentKnowledge.bestPractices',
+      domainModels: 'componentKnowledge.domainModels',
+      ci_cd: 'integrationKnowledge.ci_cd',
+      testing: 'integrationKnowledge.testing',
+      deployment: 'integrationKnowledge.deployment',
+    };
+
+    const path = categoryMap[category];
+    if (!path) {
+      return [];
+    }
+
+    return this.getNestedProperty(this.registry, path) || [];
+  }
+
+  /**
+   * 列出所有已注册的中间件（兼容 EnvironmentLoader）
+   */
+  listMiddleware() {
+    return this.list('middleware');
+  }
+
+  /**
+   * 列出所有已注册的组件（兼容 EnvironmentLoader）
+   */
+  listComponents() {
+    return this.list('components');
+  }
+
+  /**
+   * 列出所有已注册的集成配置（兼容 EnvironmentLoader）
+   */
+  listIntegrations(type) {
+    if (type) {
+      const typeMap = { ci_cd: 'ci_cd', testing: 'testing', deployment: 'deployment' };
+      return this.list(typeMap[type] || type);
+    }
+    return this.registry?.integrationKnowledge || {};
+  }
+
+  // ============================================================
+  // 激活状态管理
+  // ============================================================
+
+  /**
+   * 设置活跃配置
+   * @param {Object} profiles - 活跃配置 { environment, components, ci_cd }
+   */
+  setActiveProfiles(profiles) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    if (!this.registry.activeProfiles) {
+      this.registry.activeProfiles = {};
+    }
+
+    if (profiles.environment !== undefined) {
+      this.registry.activeProfiles.environment = profiles.environment;
+    }
+    if (profiles.components !== undefined) {
+      this.registry.activeProfiles.components = profiles.components;
+    }
+    if (profiles.ci_cd !== undefined) {
+      this.registry.activeProfiles.ci_cd = profiles.ci_cd;
+    }
+
+    this.save();
+  }
+
+  /**
+   * 获取活跃配置
+   */
+  getActiveProfiles() {
+    if (!this.registry) {
+      this.load();
+    }
+
+    return this.registry.activeProfiles || {
+      environment: 'development',
+      components: [],
+      ci_cd: null,
+      middleware: [],
+    };
+  }
+
+  /**
+   * 设置激活的环境（兼容 EnvironmentLoader）
+   */
+  setActiveEnvironment(env) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    if (!this.registry.activeProfiles) {
+      this.registry.activeProfiles = {};
+    }
+
+    this.registry.activeProfiles.environment = env;
+    this.save();
+  }
+
+  /**
+   * 设置激活的组件（兼容 EnvironmentLoader）
+   */
+  setActiveComponents(components) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    if (!this.registry.activeProfiles) {
+      this.registry.activeProfiles = {};
+    }
+
+    this.registry.activeProfiles.components = components;
+    this.save();
+  }
+
+  /**
+   * 设置激活的 CI/CD 系统（兼容 EnvironmentLoader）
+   */
+  setActiveCiCd(ciSystem) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    if (!this.registry.activeProfiles) {
+      this.registry.activeProfiles = {};
+    }
+
+    this.registry.activeProfiles.ci_cd = ciSystem;
+    this.save();
+  }
+
+  /**
+   * 激活知识条目
+   * @param {string} category - 知识类别 (middleware, components, ci_cd)
+   * @param {string} name - 条目名称
+   */
+  activate(category, name) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    if (!this.registry.activeProfiles) {
+      this.registry.activeProfiles = {
+        environment: 'development',
+        components: [],
+        ci_cd: null,
+        middleware: [],
+      };
+    }
+
+    // 确保 middleware 数组存在
+    if (!this.registry.activeProfiles.middleware) {
+      this.registry.activeProfiles.middleware = [];
+    }
+
+    switch (category) {
+      case 'middleware':
+        if (!this.registry.activeProfiles.middleware.includes(name)) {
+          this.registry.activeProfiles.middleware.push(name);
+        }
+        break;
+      case 'components':
+        if (!this.registry.activeProfiles.components.includes(name)) {
+          this.registry.activeProfiles.components.push(name);
+        }
+        break;
+      case 'ci_cd':
+        this.registry.activeProfiles.ci_cd = name;
+        break;
+      default:
+        console.warn(`Unknown category for activation: ${category}`);
+    }
+
+    this.save();
+  }
+
+  /**
+   * 停用知识条目
+   * @param {string} category - 知识类别
+   * @param {string} name - 条目名称
+   */
+  deactivate(category, name) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    if (!this.registry.activeProfiles) {
+      return;
+    }
+
+    switch (category) {
+      case 'middleware':
+        this.registry.activeProfiles.middleware =
+          (this.registry.activeProfiles.middleware || []).filter(n => n !== name);
+        break;
+      case 'components':
+        this.registry.activeProfiles.components =
+          (this.registry.activeProfiles.components || []).filter(n => n !== name);
+        break;
+      case 'ci_cd':
+        if (this.registry.activeProfiles.ci_cd === name) {
+          this.registry.activeProfiles.ci_cd = null;
+        }
+        break;
+    }
+
+    this.save();
+  }
+
+  /**
+   * 检查知识条目是否激活
+   * @param {string} category - 知识类别
+   * @param {string} name - 条目名称
+   */
+  isActive(category, name) {
+    if (!this.registry) {
+      this.load();
+    }
+
+    if (!this.registry.activeProfiles) {
+      return false;
+    }
+
+    switch (category) {
+      case 'middleware':
+        return (this.registry.activeProfiles.middleware || []).includes(name);
+      case 'components':
+        return (this.registry.activeProfiles.components || []).includes(name);
+      case 'ci_cd':
+        return this.registry.activeProfiles.ci_cd === name;
+      default:
+        return false;
+    }
+  }
+
+  /**
+   * 获取所有激活的中间件
+   */
+  getActiveMiddleware() {
+    if (!this.registry) {
+      this.load();
+    }
+    return this.registry.activeProfiles?.middleware || [];
+  }
+
+  /**
+   * 获取所有激活的组件
+   */
+  getActiveComponents() {
+    if (!this.registry) {
+      this.load();
+    }
+    return this.registry.activeProfiles?.components || [];
+  }
+
+  // ============================================================
+  // 文件注册
+  // ============================================================
+
+  /**
+   * 从知识文件自动注册
+   * @param {string} filePath - 知识文件路径
+   */
+  registerFromFile(filePath) {
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const knowledge = yaml.load(content);
+
+    const kind = knowledge.kind;
+    const meta = knowledge.metadata || knowledge.meta;
+
+    if (!meta || !meta.name) {
+      throw new Error('Knowledge file missing metadata.name');
+    }
+
+    const relativePath = path.relative(this.envDir, filePath);
+
+    const entry = {
+      name: meta.name,
+      path: relativePath,
+      version: meta.version || '1.0',
+      tags: meta.tags || [],
+    };
+
+    // 根据 kind 确定类别
+    const kindToCategory = {
+      [KNOWLEDGE_TYPES.MIDDLEWARE]: 'middleware',
+      [KNOWLEDGE_TYPES.INFRASTRUCTURE]: 'infrastructure',
+      [KNOWLEDGE_TYPES.COMPONENT]: 'components',
+      [KNOWLEDGE_TYPES.INTEGRATION]: 'ci_cd',  // 需要根据 spec.type 进一步区分
+    };
+
+    let category = kindToCategory[kind];
+
+    // 对于 Integration 类型，根据 spec.type 细分
+    if (kind === KNOWLEDGE_TYPES.INTEGRATION && knowledge.spec?.type) {
+      const integrationTypeMap = {
+        'ci-cd': 'ci_cd',
+        'ci_cd': 'ci_cd',
+        'testing': 'testing',
+        'deployment': 'deployment',
+      };
+      category = integrationTypeMap[knowledge.spec.type] || 'ci_cd';
+    }
+
+    if (!category) {
+      throw new Error(`Unknown knowledge kind: ${kind}`);
+    }
+
+    this.register(category, entry);
+    return entry;
+  }
+
+  /**
+   * 同步目录中的所有知识文件
+   * @param {string} subDir - 子目录名
+   */
+  syncFromDirectory(subDir) {
+    const dirPath = path.join(this.envDir, subDir);
+    if (!fs.existsSync(dirPath)) {
+      return [];
+    }
+
+    const registered = [];
+    const files = fs.readdirSync(dirPath, { withFileTypes: true });
+
+    for (const file of files) {
+      if (file.isFile() && (file.name.endsWith('.yaml') || file.name.endsWith('.yml'))) {
+        try {
+          const entry = this.registerFromFile(path.join(dirPath, file.name));
+          registered.push(entry);
+        } catch (e) {
+          console.warn(`Failed to register ${file.name}:`, e.message);
+        }
+      } else if (file.isDirectory()) {
+        // 处理组件目录（如 components/auth/component.yaml）
+        const subDirPath = path.join(dirPath, file.name);
+        const componentFile = path.join(subDirPath, 'component.yaml');
+        if (fs.existsSync(componentFile)) {
+          try {
+            const entry = this.registerFromFile(componentFile);
+            registered.push(entry);
+          } catch (e) {
+            console.warn(`Failed to register ${file.name}:`, e.message);
+          }
+        }
+      }
+    }
+
+    return registered;
+  }
+
+  /**
+   * 同步所有知识文件
+   */
+  syncAll() {
+    const results = {
+      middleware: this.syncFromDirectory('env-knowledge/middleware'),
+      infrastructure: this.syncFromDirectory('env-knowledge/infrastructure'),
+      components: this.syncFromDirectory('component-lib/components'),
+      ci_cd: this.syncFromDirectory('integration/ci-cd'),
+      testing: this.syncFromDirectory('integration/testing'),
+      deployment: this.syncFromDirectory('integration/deployment'),
+    };
+
+    return results;
+  }
+
+  // ============================================================
+  // 工具方法
+  // ============================================================
+
+  /**
+   * 获取嵌套属性
+   */
+  getNestedProperty(obj, path) {
+    return path.split('.').reduce((current, key) => {
+      return current && current[key] !== undefined ? current[key] : null;
+    }, obj);
+  }
+
+  /**
+   * 设置嵌套属性
+   */
+  setNestedProperty(obj, path, value) {
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    const target = keys.reduce((current, key) => {
+      if (!current[key]) {
+        current[key] = {};
+      }
+      return current[key];
+    }, obj);
+    target[lastKey] = value;
+  }
+}
+
+// 向后兼容：EnvironmentLoader 是 EnvironmentRegistry 的别名
+export { EnvironmentRegistry as EnvironmentLoader };
+
+export default EnvironmentRegistry;