@chongyan/autospec 1.0.1 → 1.0.3

package/scripts/config/hooks.config.js

@@ -1,197 +0,0 @@
-#!/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

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