@chongyan/autospec 1.0.1

package/plugins/hooks/environment-manager.js

@@ -0,0 +1,778 @@
+#!/usr/bin/env node
+
+/**
+ * AutoSpec Hook: Environment Manager
+ *
+ * 环境知识管理 Hook，合并了验证和进化功能：
+ * - PreToolUse: 环境知识验证（原 environment-validator.js）
+ * - Stop: 环境进化检查（原 environment-evolution.js）
+ *
+ * 职责：
+ * 1. 验证环境知识 YAML 文件的结构和内容
+ * 2. 检测敏感信息（密码、API Key 等）
+ * 3. 会话结束时检查可沉淀的环境知识
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { PatternLoader } from './lib/detection-pattern-loader.js';
+import { createHookLogger, safeJsonParse, handleHookError, readStdin, findProjectRootAsync, fileExists } from './lib/hook-logger.js';
+import {
+  discoverSourceDirsSimple,
+  scanCodePatternsFast,
+  scanEnvVarPatternsFast,
+  scanDependenciesFast,
+} from './lib/source-code-scanner.js';
+
+const logger = createHookLogger('environment-manager');
+
+// 动态加载 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
+    logger.debug('js-yaml not available, using fallback YAML parser');
+  }
+  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 内容（异步版本，推荐使用）
+ */
+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);
+}
+
+// ========== 验证函数（PreToolUse）==========
+
+/**
+ * 验证环境知识结构
+ */
+function validateKnowledgeStructure(knowledge) {
+  const errors = [];
+
+  if (!knowledge.apiVersion) {
+    errors.push('缺少必需字段：apiVersion');
+  }
+
+  if (!knowledge.kind) {
+    errors.push('缺少必需字段：kind');
+  }
+
+  if (!knowledge.metadata && !knowledge.meta) {
+    errors.push('缺少必需字段：metadata 或 meta');
+  }
+
+  if (!knowledge.spec) {
+    errors.push('缺少必需字段：spec');
+  }
+
+  return errors;
+}
+
+/**
+ * 验证中间件知识
+ */
+function validateMiddlewareKnowledge(knowledge) {
+  const errors = [];
+  const spec = knowledge.spec;
+  const meta = knowledge.metadata || knowledge.meta;
+
+  if (!spec.type) {
+    errors.push('中间件知识缺少 type 字段');
+  }
+
+  if (!meta?.name) {
+    errors.push('中间件知识缺少 metadata.name 字段');
+  }
+
+  if (spec.connection && !spec.connection.template) {
+    errors.push('中间件知识缺少 connection.template 字段');
+  }
+
+  // 检查危险命令
+  if (spec.validation?.healthCheck) {
+    const dangerousPatterns = [/rm\s+-rf/, /sudo/, /mkfs/, /dd\s+if=/];
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(spec.validation.healthCheck)) {
+        errors.push('healthCheck 包含潜在危险的命令');
+        break;
+      }
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * 验证组件知识
+ */
+function validateComponentKnowledge(knowledge) {
+  const errors = [];
+  const spec = knowledge.spec;
+  const meta = knowledge.metadata || knowledge.meta;
+
+  if (!spec.type) {
+    errors.push('组件知识缺少 type 字段');
+  }
+
+  if (!meta?.name) {
+    errors.push('组件知识缺少 metadata.name 字段');
+  }
+
+  if (!spec.description) {
+    errors.push('组件知识缺少 description 字段');
+  }
+
+  if (spec.interfaces && Array.isArray(spec.interfaces)) {
+    for (const iface of spec.interfaces) {
+      if (!iface.name) {
+        errors.push('接口定义缺少 name 字段');
+      }
+    }
+  }
+
+  return errors;
+}
+
+/**
+ * 验证集成知识
+ */
+function validateIntegrationKnowledge(knowledge) {
+  const errors = [];
+  const spec = knowledge.spec;
+  const meta = knowledge.metadata || knowledge.meta;
+
+  if (!spec.type) {
+    errors.push('集成知识缺少 type 字段');
+  }
+
+  if (!meta?.name) {
+    errors.push('集成知识缺少 metadata.name 字段');
+  }
+
+  return errors;
+}
+
+/**
+ * 检查硬编码敏感信息
+ */
+function checkSensitiveInfo(content) {
+  const sensitivePatterns = [
+    /password\s*[:=]\s*['"][^'"]+['"]/i,
+    /secret\s*[:=]\s*['"][^'"]+['"]/i,
+    /api[_-]?key\s*[:=]\s*['"][^'"]+['"]/i,
+  ];
+
+  for (const pattern of sensitivePatterns) {
+    if (pattern.test(content)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * 处理 PreToolUse 事件：环境知识验证
+ */
+async function handlePreToolUse(input) {
+  // 确保 js-yaml 已加载（如果可用）
+  await ensureYaml();
+
+  const toolName = input.tool_name;
+  const toolInput = input.tool_input || {};
+
+  // 只检查 Write 和 Edit 操作
+  if (!['Write', 'Edit'].includes(toolName)) {
+    process.exit(0);
+  }
+
+  const filePath = toolInput.file_path || '';
+
+  // 只检查 environment 目录下的文件
+  if (!filePath.includes('/environment/') && !filePath.includes('\\environment\\')) {
+    process.exit(0);
+  }
+
+  // 只检查 YAML 文件
+  if (!filePath.endsWith('.yaml') && !filePath.endsWith('.yml')) {
+    process.exit(0);
+  }
+
+  // 获取文件内容
+  const content = toolInput.content || toolInput.new_string || '';
+
+  if (!content) {
+    process.exit(0);
+  }
+
+  // 检查硬编码敏感信息
+  if (checkSensitiveInfo(content)) {
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason:
+          'ENVIRONMENT SECURITY: 检测到可能的硬编码敏感信息。请使用环境变量替代。',
+      },
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+  }
+
+  // 解析 YAML
+  let knowledge;
+  try {
+    knowledge = parseYaml(content);
+  } catch (e) {
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: `ENVIRONMENT YAML ERROR: YAML 解析失败 - ${e.message}`,
+      },
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+  }
+
+  // 验证基本结构
+  const structureErrors = validateKnowledgeStructure(knowledge);
+  if (structureErrors.length > 0) {
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: `ENVIRONMENT STRUCTURE ERROR: ${structureErrors.join('; ')}`,
+      },
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+  }
+
+  // 根据 kind 进行专项验证
+  let errors = [];
+  switch (knowledge.kind) {
+    case 'MiddlewareKnowledge':
+      errors = validateMiddlewareKnowledge(knowledge);
+      break;
+    case 'ComponentKnowledge':
+      errors = validateComponentKnowledge(knowledge);
+      break;
+    case 'IntegrationKnowledge':
+      errors = validateIntegrationKnowledge(knowledge);
+      break;
+    default:
+      // 未知类型，允许通过
+      break;
+  }
+
+  if (errors.length > 0) {
+    const output = {
+      hookSpecificOutput: {
+        hookEventName: 'PreToolUse',
+        permissionDecision: 'deny',
+        permissionDecisionReason: `ENVIRONMENT VALIDATION ERROR: ${errors.join('; ')}`,
+      },
+    };
+    process.stdout.write(JSON.stringify(output));
+    process.exit(0);
+  }
+
+  // 验证通过
+  process.exit(0);
+}
+
+// ========== 进化检查（Stop）==========
+
+/**
+ * 使用 PatternLoader 检测中间件 - 使用公共模块
+ */
+async function detectMiddlewareWithPatternLoader(projectRoot, patternLoader) {
+  const middlewarePatterns = patternLoader.getMiddlewarePatterns();
+  const detected = [];
+  const sourceDirs = discoverSourceDirsSimple(projectRoot);
+
+  if (sourceDirs.length === 0) {
+    sourceDirs.push('src');
+  }
+
+  for (const dir of sourceDirs) {
+    const dirPath = path.join(projectRoot, dir);
+    if (!fs.existsSync(dirPath)) continue;
+
+    for (const [name, pattern] of Object.entries(middlewarePatterns)) {
+      if (detected.includes(name)) continue;
+
+      // 检测代码模式
+      if (pattern.codePatterns) {
+        const found = scanCodePatternsFast(dirPath, pattern.codePatterns);
+        if (found) {
+          detected.push(name);
+          continue;
+        }
+      }
+
+      // 检测环境变量模式
+      if (pattern.envVarPatterns) {
+        const found = scanEnvVarPatternsFast(dirPath, pattern.envVarPatterns);
+        if (found) {
+          detected.push(name);
+        }
+      }
+    }
+  }
+
+  // 从依赖文件检测
+  const depDetected = scanDependenciesFast(projectRoot, middlewarePatterns);
+  for (const name of depDetected) {
+    if (!detected.includes(name)) {
+      detected.push(name);
+    }
+  }
+
+  return detected;
+}
+
+/**
+ * 检查中间件是否已注册
+ */
+function checkRegisteredMiddleware(projectRoot, middlewareNames) {
+  const registryPath = path.join(projectRoot, '.autospec', 'environment', 'registry.json');
+
+  if (!fs.existsSync(registryPath)) {
+    return middlewareNames.map(name => ({ name, registered: false, active: false }));
+  }
+
+  try {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+    const registered = registry.environmentKnowledge?.middleware?.map(m => m.name) || [];
+    const active = registry.activeProfiles?.middleware || [];
+
+    return middlewareNames.map(name => ({
+      name,
+      registered: registered.includes(name),
+      active: active.includes(name),
+    }));
+  } catch (e) {
+    return middlewareNames.map(name => ({ name, registered: false, active: false }));
+  }
+}
+
+/**
+ * 检测组件 - 扫描 package.json 中的组织内部组件
+ */
+function detectComponents(projectRoot) {
+  const detected = [];
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+
+  if (!fs.existsSync(packageJsonPath)) {
+    return detected;
+  }
+
+  try {
+    const pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    const allDeps = {
+      ...pkg.dependencies,
+      ...pkg.devDependencies
+    };
+
+    // 检测以 @org/ 或组织特定前缀开头的包
+    const orgPrefix = '@'; // 可配置
+    for (const dep of Object.keys(allDeps)) {
+      if (dep.startsWith('@') && dep.includes('/')) {
+        // 跳过标准作用域包
+        const scope = dep.split('/')[0];
+        if (!['@types', '@babel', '@eslint', '@angular', '@vue', '@react'].includes(scope)) {
+          detected.push(dep);
+        }
+      }
+    }
+  } catch (e) {
+    // 忽略解析错误
+  }
+
+  return detected;
+}
+
+/**
+ * 检测设计文档变更 - 扫描 specs/ 和 docs/ 目录
+ */
+function detectDesignDocChanges(projectRoot) {
+  const changes = [];
+  const dirsToCheck = [
+    'specs',
+    'docs/architecture',
+    'docs/api',
+    'docs/database',
+    'docs/product'
+  ];
+
+  for (const dir of dirsToCheck) {
+    const dirPath = path.join(projectRoot, dir);
+    if (fs.existsSync(dirPath)) {
+      try {
+        const files = fs.readdirSync(dirPath);
+        if (files.length > 0) {
+          changes.push({ type: 'design', path: dir, count: files.length });
+        }
+      } catch (e) {
+        // 忽略错误
+      }
+    }
+  }
+
+  return changes;
+}
+
+/**
+ * 检测业务知识变更 - 扫描 knowledge/domain/ 目录
+ */
+function detectBusinessKnowledgeChanges(projectRoot) {
+  const changes = [];
+  const dirsToCheck = [
+    'knowledge/domain',
+    'docs/business'
+  ];
+
+  for (const dir of dirsToCheck) {
+    const dirPath = path.join(projectRoot, dir);
+    if (fs.existsSync(dirPath)) {
+      try {
+        const files = fs.readdirSync(dirPath);
+        if (files.length > 0) {
+          changes.push({ type: 'business', path: dir, count: files.length });
+        }
+      } catch (e) {
+        // 忽略错误
+      }
+    }
+  }
+
+  return changes;
+}
+
+/**
+ * 检查组件是否已注册
+ */
+function checkRegisteredComponents(projectRoot, componentNames) {
+  const registryPath = path.join(projectRoot, '.autospec', 'environment', 'registry.json');
+
+  if (!fs.existsSync(registryPath)) {
+    return componentNames.map(name => ({ name, registered: false, active: false }));
+  }
+
+  try {
+    const registry = JSON.parse(fs.readFileSync(registryPath, 'utf-8'));
+    const registered = registry.componentKnowledge?.components?.map(c => c.name) || [];
+    const active = registry.activeProfiles?.components || [];
+
+    return componentNames.map(name => ({
+      name,
+      registered: registered.includes(name),
+      active: active.includes(name),
+    }));
+  } catch (e) {
+    return componentNames.map(name => ({ name, registered: false, active: false }));
+  }
+}
+
+/**
+ * 处理 Stop 事件：环境进化检查
+ */
+async function handleStop(projectRoot) {
+  const envDir = path.join(projectRoot, '.autospec', 'environment');
+
+  // 如果环境目录不存在，跳过
+  if (!fs.existsSync(envDir)) {
+    process.exit(0);
+  }
+
+  // 使用 PatternLoader 检测中间件（异步版本，尝试加载 js-yaml）
+  const autospecDir = path.join(projectRoot, '.autospec');
+  const patternLoader = new PatternLoader(autospecDir);
+  await patternLoader.loadAsync();
+
+  // 1. 检测中间件
+  const detectedMiddleware = await detectMiddlewareWithPatternLoader(projectRoot, patternLoader);
+  const middlewareStatus = checkRegisteredMiddleware(projectRoot, detectedMiddleware);
+  const middlewareNeedAction = middlewareStatus.filter(m => !m.registered || !m.active);
+
+  // 2. 检测组件
+  const detectedComponents = detectComponents(projectRoot);
+  const componentStatus = checkRegisteredComponents(projectRoot, detectedComponents);
+  const componentNeedAction = componentStatus.filter(c => !c.registered || !c.active);
+
+  // 3. 检测设计文档变更
+  const designDocChanges = detectDesignDocChanges(projectRoot);
+
+  // 4. 检测业务知识变更
+  const businessKnowledgeChanges = detectBusinessKnowledgeChanges(projectRoot);
+
+  // 汇总需要处理的事项
+  const hasMiddlewareAction = middlewareNeedAction.length > 0;
+  const hasComponentAction = componentNeedAction.length > 0;
+  const hasDesignChanges = designDocChanges.length > 0;
+  const hasBusinessChanges = businessKnowledgeChanges.length > 0;
+
+  if (!hasMiddlewareAction && !hasComponentAction && !hasDesignChanges && !hasBusinessChanges) {
+    process.exit(0);
+  }
+
+  // 生成提醒消息
+  let message = '[AutoSpec Environment] ';
+  const actions = [];
+
+  // 中间件提醒
+  if (hasMiddlewareAction) {
+    const unregistered = middlewareNeedAction.filter(m => !m.registered).map(m => m.name);
+    const inactive = middlewareNeedAction.filter(m => m.registered && !m.active).map(m => m.name);
+
+    if (unregistered.length > 0) {
+      actions.push(`新中间件：${unregistered.join(', ')}`);
+    }
+    if (inactive.length > 0) {
+      actions.push(`未激活中间件：${inactive.join(', ')}`);
+    }
+  }
+
+  // 组件提醒
+  if (hasComponentAction) {
+    const unregistered = componentNeedAction.filter(c => !c.registered).map(c => c.name);
+    const inactive = componentNeedAction.filter(c => c.registered && !c.active).map(c => c.name);
+
+    if (unregistered.length > 0) {
+      actions.push(`新组件：${unregistered.join(', ')}`);
+    }
+    if (inactive.length > 0) {
+      actions.push(`未激活组件：${inactive.join(', ')}`);
+    }
+  }
+
+  // 设计文档变更提醒
+  if (hasDesignChanges) {
+    const paths = designDocChanges.map(d => d.path).join(', ');
+    actions.push(`设计文档变更：${paths}`);
+  }
+
+  // 业务知识变更提醒
+  if (hasBusinessChanges) {
+    const paths = businessKnowledgeChanges.map(b => b.path).join(', ');
+    actions.push(`业务知识变更：${paths}`);
+  }
+
+  message += actions.join('；') + '。运行 autospec env:sync 可同步最新知识。';
+
+  const output = {
+    hookSpecificOutput: {
+      hookEventName: 'Stop',
+      additionalContext: message,
+    },
+  };
+
+  process.stdout.write(JSON.stringify(output));
+}
+
+/**
+ * 主函数
+ */
+async function main() {
+  try {
+    const inputRaw = await readStdin(1000);
+    const input = JSON.parse(inputRaw);
+
+    const eventName = input.event_name;
+
+    // 根据事件类型分发
+    if (eventName === 'PreToolUse') {
+      await handlePreToolUse(input);
+    } else if (eventName === 'Stop') {
+      const cwd = input.cwd || process.cwd();
+      const projectRoot = await findProjectRootAsync(cwd);
+
+      if (!projectRoot) {
+        process.exit(0);
+      }
+
+      await handleStop(projectRoot);
+    } else {
+      logger.debug('Unknown event type, skipping', { eventName });
+    }
+
+    process.exit(0);
+
+  } catch (e) {
+    // 输出错误信息，使用 handleHookError
+    const result = handleHookError('environment-manager', e, {
+      eventName: 'Unknown'
+    });
+    process.stdout.write(JSON.stringify(result.hookSpecificOutput));
+    process.exit(0);
+  }
+}
+
+main();