@chongyan/autospec 1.0.1

package/scripts/config/hooks.config.js

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+/**
+ * AutoSpec 声明式 Hook 配置
+ *
+ * 替代硬编码的 hook 注册逻辑，使用声明式配置管理所有 hooks。
+ *
+ * 优先级规则（大数字先执行）：
+ * - 200: trace-initialization (最高优先级，Trace ID 初始化)
+ * - 100: frozen-zone (保护核心文件)
+ * - 90: scope-sentinel (范围保护)
+ * - 85: constitution-guard (宪法门禁)
+ * - 80: layer1-validator (Layer 1 强制检查 + 结果捕获 + 质量追踪)
+ * - 75: environment-manager (环境知识验证 + 环境进化检查)
+ * - 50: ai-project-guard (AI 安全检查 + 效果验证)
+ * - 35: execution-tracker (执行追踪)
+ *
+ * 注意：evolution-trigger 和 practice-log-reminder 已合并到 skill：
+ * - knowledge/guides/support/practice-logger.md
+ *
+ * 缓存键规范：
+ * - ai-project:{projectRoot} - AI 项目检测结果
+ * - stage-check:{projectRoot}:stage - 当前阶段缓存
+ */
+
+export const HOOKS_CONFIG = {
+  // PreToolUse - 工具执行前检查
+  PreToolUse: [
+    {
+      name: 'trace-initialization',
+      script: 'plugins/hooks/trace-initialization.js',
+      matcher: 'Write',
+      priority: 200,
+      description: '流程启动时初始化 Trace ID'
+    },
+    {
+      name: 'frozen-zone',
+      script: 'plugins/hooks/frozen-zone-guard.js',
+      matcher: 'Write|Edit',
+      priority: 100,
+      description: '保护冻结区文件不被修改'
+    },
+    {
+      name: 'scope-sentinel',
+      script: 'plugins/hooks/scope-sentinel.js',
+      matcher: 'Write|Edit',
+      priority: 90,
+      description: '实现阶段范围防漂移'
+    },
+    {
+      name: 'constitution-guard',
+      script: 'plugins/hooks/constitution-guard.js',
+      matcher: 'Write|Edit',
+      priority: 85,
+      description: '检查启动门禁是否遵循'
+    },
+    {
+      name: 'layer1-validator',
+      script: 'plugins/hooks/layer1-validator.js',
+      matcher: 'Write|Edit|Bash',
+      priority: 80,
+      description: 'Layer 1 强制检查（PreToolUse）+ 结果捕获（PostToolUse）+ 质量追踪'
+    },
+    {
+      name: 'environment-manager',
+      script: 'plugins/hooks/environment-manager.js',
+      matcher: 'Write|Edit',
+      priority: 75,
+      description: '环境知识验证（PreToolUse）+ 环境进化检查（Stop）'
+    },
+    {
+      name: 'ai-project-guard',
+      script: 'plugins/hooks/ai-project-guard.js',
+      matcher: '', // 所有 Bash 命令
+      priority: 50,
+      condition: 'isAIProject', // 条件执行：仅 AI 项目
+      description: 'AI 项目安全检查 + 效果验证'
+    }
+  ],
+
+  // PostToolUse - 工具执行后处理
+  PostToolUse: [
+    {
+      name: 'artifact-evaluation',
+      script: 'plugins/hooks/artifact-evaluation-hook.js',
+      matcher: 'Write',
+      priority: 36,
+      description: '产出物评测（结构检查 + AI 质量评估触发）'
+    },
+    {
+      name: 'execution-tracker',
+      script: 'plugins/hooks/execution-tracker.js',
+      matcher: 'Write|Edit|Agent',
+      priority: 35,
+      description: '追踪关键步骤执行日志（skill 加载、agent 调用、产物生成、阶段完成）'
+    },
+    {
+      name: 'layer1-validator',
+      script: 'plugins/hooks/layer1-validator.js',
+      matcher: 'Write|Edit|Bash|Agent|AskUserQuestion',
+      priority: 40,
+      description: 'Layer 1 结果捕获 + 质量指标追踪'
+    },
+    {
+      name: 'ai-project-guard',
+      script: 'plugins/hooks/ai-project-guard.js',
+      matcher: 'Bash',
+      priority: 50,
+      condition: 'isAIProject',
+      description: 'AI 项目安全检查 + 效果验证'
+    },
+    {
+      name: 'pipeline-observer',
+      script: 'plugins/hooks/pipeline-observer.js',
+      matcher: '',
+      priority: 10,
+      description: '全链路事件采集和分析'
+    }
+  ],
+
+  // Stop - 会话结束
+  Stop: [
+    {
+      name: 'pipeline-observer',
+      script: 'plugins/hooks/pipeline-observer.js',
+      priority: 10,
+      description: '会话结束时生成评测报告'
+    },
+    {
+      name: 'environment-manager',
+      script: 'plugins/hooks/environment-manager.js',
+      priority: 15,
+      description: '环境知识验证 + 环境进化检查'
+    }
+  ]
+};
+
+/**
+ * 获取指定事件类型的 hooks，按优先级排序
+ */
+export function getHooksForEvent(eventName) {
+  const hooks = HOOKS_CONFIG[eventName] || [];
+  return hooks.sort((a, b) => b.priority - a.priority);
+}
+
+/**
+ * 检查 hook 是否应该对某个工具执行
+ */
+export function shouldHookRun(hook, toolName) {
+  // 无条件执行（matcher 为空）
+  if (!hook.matcher) {
+    return true;
+  }
+
+  // 检查工具名匹配
+  const matchers = hook.matcher.split('|').map(m => m.trim());
+  return matchers.includes(toolName);
+}
+
+/**
+ * 构建完整的 hook 路径
+ */
+export function resolveHookPath(scriptPath, baseDir) {
+  if (scriptPath.startsWith('/')) {
+    return scriptPath;
+  }
+  return `${baseDir}/${scriptPath}`;
+}
+
+/**
+ * 生成 Claude Code hooks 配置
+ * 输出格式与 claude-integration.js 兼容
+ */
+export function generateClaudeHooksConfig(autospecDir) {
+  const configs = [];
+
+  for (const [event, hooks] of Object.entries(HOOKS_CONFIG)) {
+    for (const hook of hooks) {
+      // 构建命令
+      const scriptPath = resolveHookPath(hook.script, autospecDir);
+      const command = `node ${scriptPath}`;
+
+      configs.push({
+        event,
+        command,
+        name: hook.name,
+        priority: hook.priority,
+        matcher: hook.matcher || '',
+        description: hook.description
+      });
+    }
+  }
+
+  return configs;
+}
+
+export default HOOKS_CONFIG;

package/scripts/evolution/evolution-router.js

@@ -0,0 +1,273 @@
+/**
+ * Evolution Router - 进化分流器
+ *
+ * 实现进化分区决策逻辑
+ * 集成记忆模块：读取 team-preferences 和 constraints 辅助决策
+ */
+
+import path from 'path';
+import os from 'os';
+import {
+  KNOWLEDGE_ZONES,
+  KNOWLEDGE_SCOPE,
+  GLOBAL_AUTOSPEC_DIR,
+  ORG_AUTOSPEC_DIR
+} from '../install/constants.js';
+
+// 记忆模块延迟加载
+let memoryManager = null;
+function getMemoryManager() {
+  if (memoryManager === null) {
+    try {
+      // eslint-disable-next-line import/no-unresolved
+      memoryManager = require('../../plugins/hooks/lib/memory-manager.js');
+    } catch (e) {
+      memoryManager = false; // 标记为不可用
+    }
+  }
+  return memoryManager || null;
+}
+
+/**
+ * 获取进化分区
+ * @param {string} knowledgePath - 知识路径
+ * @returns {string} 知识分区
+ */
+export function getEvolutionZone(knowledgePath) {
+  // 冻结区检测
+  if (/\/knowledge\/principles\/(constitution|evolution|design-philosophy)\.md$/.test(knowledgePath)) {
+    return KNOWLEDGE_ZONES.FROZEN;
+  }
+
+  // 受控区检测
+  if (/\/knowledge\/(process|guides\/support|config|checklists)\//.test(knowledgePath)) {
+    return KNOWLEDGE_ZONES.CONTROLLED;
+  }
+
+  // 自由区检测
+  if (/\/knowledge\/guides\/stages\/|\/knowledge\/domain\/|\/plugins\/skills\//.test(knowledgePath)) {
+    return KNOWLEDGE_ZONES.FREE;
+  }
+
+  // 默认返回受控区
+  return KNOWLEDGE_ZONES.CONTROLLED;
+}
+
+/**
+ * 获取进化目标路径
+ * @param {string} targetScope - 目标作用域 (global|org)
+ * @param {string} knowledgeType - 知识类型
+ * @param {Object} options - 选项
+ * @returns {string} 目标路径
+ */
+export function getEvolutionTargetPath(targetScope, knowledgeType, options = {}) {
+  const { orgName = null } = options;
+
+  const baseDir = targetScope === KNOWLEDGE_SCOPE.ORG
+    ? path.join(os.homedir(), ORG_AUTOSPEC_DIR, orgName)
+    : path.join(os.homedir(), GLOBAL_AUTOSPEC_DIR);
+
+  return path.join(baseDir, knowledgeType);
+}
+
+/**
+ * 路由进化决策
+ *
+ * @param {string} knowledgePath - 知识路径
+ * @param {Object} options - 选项
+ * @returns {Object} 进化决策 { action, target, path, reason }
+ */
+export function routeEvolution(knowledgePath, options = {}) {
+  const { projectRoot = '.', orgName = null, autoApprove = false } = options;
+
+  // 获取知识分区
+  const zone = getEvolutionZone(knowledgePath);
+
+  // 尝试从记忆模块获取进化偏好
+  let evolutionMode = 'auto'; // 默认自动进化
+  const mm = getMemoryManager();
+  if (mm) {
+    try {
+      const preferences = mm.getTeamPreferences(projectRoot);
+      evolutionMode = preferences?.workflowPreferences?.evolutionMode || 'auto';
+    } catch (e) {
+      // 使用默认模式
+    }
+  }
+
+  // 根据分区决定进化动作
+  switch (zone) {
+    case KNOWLEDGE_ZONES.FROZEN:
+      // 冻结区：拒绝进化
+      return {
+        action: 'reject',
+        reason: 'frozen-zone',
+        message: '冻结区知识不允许进化'
+      };
+
+    case KNOWLEDGE_ZONES.CONTROLLED:
+      // 受控区：根据偏好决定
+      if (autoApprove || evolutionMode === 'auto') {
+        // 自动回流到全局
+        return {
+          action: 'auto-merge',
+          target: KNOWLEDGE_SCOPE.GLOBAL,
+          path: getEvolutionTargetPath(KNOWLEDGE_SCOPE.GLOBAL, 'knowledge', { orgName }),
+          reason: 'controlled-zone-auto',
+          message: '受控区知识自动回流到全局'
+        };
+      } else {
+        // 提议回流，需要人工批准
+        return {
+          action: 'propose',
+          target: KNOWLEDGE_SCOPE.GLOBAL,
+          path: getEvolutionTargetPath(KNOWLEDGE_SCOPE.GLOBAL, 'knowledge', { orgName }),
+          reason: 'controlled-zone-manual',
+          message: '受控区知识需要人工批准后才能回流'
+        };
+      }
+
+    case KNOWLEDGE_ZONES.FREE:
+    default:
+      // 自由区：自动进化和回流
+      if (autoApprove || evolutionMode === 'auto') {
+        return {
+          action: 'auto-merge',
+          target: KNOWLEDGE_SCOPE.GLOBAL,
+          path: getEvolutionTargetPath(KNOWLEDGE_SCOPE.GLOBAL, 'skills', { orgName }),
+          reason: 'free-zone-auto',
+          message: '自由区知识自动回流到全局技能库'
+        };
+      } else {
+        return {
+          action: 'propose',
+          target: KNOWLEDGE_SCOPE.GLOBAL,
+          path: getEvolutionTargetPath(KNOWLEDGE_SCOPE.GLOBAL, 'skills', { orgName }),
+          reason: 'free-zone-manual',
+          message: '自由区知识建议回流，是否确认？'
+        };
+      }
+  }
+}
+
+/**
+ * 路由进化到组织级别
+ *
+ * @param {string} knowledgePath - 知识路径
+ * @param {string} orgName - 组织名称
+ * @param {Object} options - 选项
+ * @returns {Object} 进化决策
+ */
+export function routeEvolutionToOrg(knowledgePath, orgName, options = {}) {
+  const { autoApprove = false } = options;
+
+  const zone = getEvolutionZone(knowledgePath);
+
+  // 冻结区不允许任何进化
+  if (zone === KNOWLEDGE_ZONES.FROZEN) {
+    return {
+      action: 'reject',
+      reason: 'frozen-zone',
+      message: '冻结区知识不允许进化到组织'
+    };
+  }
+
+  // 其他分区都可以进化到组织
+  if (autoApprove) {
+    return {
+      action: 'auto-merge',
+      target: KNOWLEDGE_SCOPE.ORG,
+      path: getEvolutionTargetPath(KNOWLEDGE_SCOPE.ORG, 'skills', { orgName }),
+      reason: 'org-auto',
+      message: `自动进化到组织 ${orgName}`
+    };
+  }
+
+  return {
+    action: 'propose',
+    target: KNOWLEDGE_SCOPE.ORG,
+    path: getEvolutionTargetPath(KNOWLEDGE_SCOPE.ORG, 'skills', { orgName }),
+    reason: 'org-manual',
+    message: `建议进化到组织 ${orgName}，是否确认？`
+  };
+}
+
+/**
+ * 检查是否允许回流到全局
+ * 集成记忆模块的 constraints
+ *
+ * @param {string} knowledgePath - 知识路径
+ * @param {Object} options - 选项
+ * @returns {Object} 检查结果 { allowed, reason }
+ */
+export function checkGlobalMergeAllowed(knowledgePath, options = {}) {
+  const { projectRoot = '.' } = options;
+
+  // 冻结区直接拒绝
+  const zone = getEvolutionZone(knowledgePath);
+  if (zone === KNOWLEDGE_ZONES.FROZEN) {
+    return { allowed: false, reason: 'frozen-zone' };
+  }
+
+  // 尝试从记忆模块获取约束
+  const mm = getMemoryManager();
+  if (mm) {
+    try {
+      const constraints = mm.getConstraints(projectRoot);
+      const hardConstraints = constraints?.hardConstraints || [];
+
+      // 检查是否有硬约束阻止回流
+      for (const constraint of hardConstraints) {
+        if (constraint.content.includes('禁止回流') || constraint.content.includes('不允许全局')) {
+          return { allowed: false, reason: 'hard-constraint', detail: constraint.content };
+        }
+      }
+    } catch (e) {
+      // 使用默认行为
+    }
+  }
+
+  return { allowed: true, reason: 'ok' };
+}
+
+/**
+ * 获取回流目标列表
+ *
+ * @param {string} knowledgePath - 知识路径
+ * @param {Object} options - 选项
+ * @returns {Array} 可用的回流目标
+ */
+export function getEvolutionTargets(knowledgePath, options = {}) {
+  const { orgName = null } = options;
+
+  const targets = [
+    {
+      scope: KNOWLEDGE_SCOPE.GLOBAL,
+      label: '用户全局',
+      path: getEvolutionTargetPath(KNOWLEDGE_SCOPE.GLOBAL, 'skills'),
+      priority: 1
+    }
+  ];
+
+  // 如果有组织名称，添加组织目标
+  if (orgName) {
+    targets.push({
+      scope: KNOWLEDGE_SCOPE.ORG,
+      label: `组织: ${orgName}`,
+      path: getEvolutionTargetPath(KNOWLEDGE_SCOPE.ORG, 'skills', { orgName }),
+      priority: 2
+    });
+  }
+
+  // 按优先级排序
+  return targets.sort((a, b) => a.priority - b.priority);
+}
+
+export default {
+  getEvolutionZone,
+  getEvolutionTargetPath,
+  routeEvolution,
+  routeEvolutionToOrg,
+  checkGlobalMergeAllowed,
+  getEvolutionTargets
+};