@chongyan/autospec 1.0.1 → 1.0.2

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
-};

package/scripts/evolution/evolution-signal-collector.js

@@ -1,307 +0,0 @@
-/**
- * Evolution Signal Collector - 进化信号收集器
- *
- * 复用 memory-manager.js 的 sessions-index 统计进化信号
- * 实现同类问题3次检测逻辑和5条 practice-log 触发逻辑
- */
-
-import {
-  MEMORY_SCOPE,
-  MEMORY_FILES
-} from '../install/constants.js';
-
-// 尝试导入记忆模块
-let memoryManager = null;
-function getMemoryManager() {
-  if (memoryManager === null) {
-    try {
-      memoryManager = require('../../plugins/hooks/lib/memory-manager.js');
-    } catch (e) {
-      memoryManager = false;
-    }
-  }
-  return memoryManager || null;
-}
-
-/**
- * 进化信号类型
- */
-export const EVOLUTION_SIGNAL_TYPES = {
-  FLOW_COMPLETE: 'flow-complete',           // 全流程完成
-  SAME_PROBLEM_3TIMES: 'same-problem-3x', // 同类问题出现3次
-  PRACTICE_LOG_5: 'practice-log-5',        // 5条 practice-log
-  MANUAL_TRIGGER: 'manual-trigger',        // 手动触发
-  HUMAN_FEEDBACK: 'human-feedback'        // 人工反馈
-};
-
-/**
- * 收集进化信号
- *
- * @param {string} projectRoot - 项目根目录
- * @returns {Object} 进化信号 { signals: [], shouldEvolve: boolean }
- */
-export function collectEvolutionSignals(projectRoot) {
-  const signals = [];
-  const mm = getMemoryManager();
-
-  // 1. 检查全流程完成信号（通过 state.json）
-  try {
-    const statePath = `${projectRoot}/.autospec/runtime/state.json`;
-    const state = mm ? mm.getMemory(MEMORY_SCOPE.PROJECT, 'runtime/state.json', projectRoot) : null;
-    if (state && state.currentStage === '06' && state.status === 'completed') {
-      signals.push({
-        type: EVOLUTION_SIGNAL_TYPES.FLOW_COMPLETE,
-        timestamp: new Date().toISOString(),
-        detail: '全流程已完成'
-      });
-    }
-  } catch (e) {
-    // 忽略错误
-  }
-
-  // 2. 检查同类问题出现3次（通过 sessions-index）
-  if (mm) {
-    try {
-      const sessionsIndex = mm.getSessionsIndex(projectRoot);
-      const problemCounts = countProblems(sessionsIndex);
-
-      for (const [problem, count] of Object.entries(problemCounts)) {
-        if (count >= 3) {
-          signals.push({
-            type: EVOLUTION_SIGNAL_TYPES.SAME_PROBLEM_3TIMES,
-            timestamp: new Date().toISOString(),
-            detail: `问题 "${problem}" 出现 ${count} 次`,
-            problem,
-            count
-          });
-        }
-      }
-    } catch (e) {
-      // 忽略错误
-    }
-  }
-
-  // 3. 检查 practice-log 数量（通过 evolution 目录）
-  try {
-    const practiceLogCount = countPracticeLogs(projectRoot);
-    if (practiceLogCount >= 5) {
-      signals.push({
-        type: EVOLUTION_SIGNAL_TYPES.PRACTICE_LOG_5,
-        timestamp: new Date().toISOString(),
-        detail: `已有 ${practiceLogCount} 条 practice-log`,
-        count: practiceLogCount
-      });
-    }
-  } catch (e) {
-    // 忽略错误
-  }
-
-  // 判断是否应该触发进化
-  const shouldEvolve = signals.length > 0;
-
-  return { signals, shouldEvolve };
-}
-
-/**
- * 统计同类问题出现次数
- * @param {Object} sessionsIndex - 会话索引
- * @returns {Object} 问题计数
- */
-function countProblems(sessionsIndex) {
-  const problemCounts = {};
-
-  if (!sessionsIndex || !sessionsIndex.sessions) {
-    return problemCounts;
-  }
-
-  for (const session of sessionsIndex.sessions) {
-    if (session.issues) {
-      for (const issue of session.issues) {
-        const key = issue.type || issue.category || 'unknown';
-        problemCounts[key] = (problemCounts[key] || 0) + 1;
-      }
-    }
-  }
-
-  return problemCounts;
-}
-
-/**
- * 统计 practice-log 数量
- * @param {string} projectRoot - 项目根目录
- * @returns {number} practice-log 数量
- */
-function countPracticeLogs(projectRoot) {
-  const mm = getMemoryManager();
-  if (!mm) {
-    return 0;
-  }
-
-  try {
-    const evolutionDir = `${projectRoot}/.autospec/evolution`;
-    const practiceLogDir = `${evolutionDir}/practice-log`;
-
-    // 尝试从记忆模块读取
-    const practiceLogs = mm.getMemory(
-      MEMORY_SCOPE.PROJECT,
-      'evolution/practice-log/index.json',
-      projectRoot
-    );
-
-    if (practiceLogs && Array.isArray(practiceLogs.entries)) {
-      return practiceLogs.entries.length;
-    }
-
-    return 0;
-  } catch (e) {
-    return 0;
-  }
-}
-
-/**
- * 记录进化信号
- *
- * @param {string} projectRoot - 项目根目录
- * @param {string} signalType - 信号类型
- * @param {Object} detail - 详细信息
- * @returns {boolean} 是否成功
- */
-export function recordEvolutionSignal(projectRoot, signalType, detail = {}) {
-  const mm = getMemoryManager();
-  if (!mm) {
-    return false;
-  }
-
-  try {
-    const signal = {
-      type: signalType,
-      timestamp: new Date().toISOString(),
-      ...detail
-    };
-
-    // 读取现有信号
-    const existingSignals = mm.getMemory(
-      MEMORY_SCOPE.PROJECT,
-      'evolution/signals.json',
-      projectRoot
-    ) || { signals: [] };
-
-    existingSignals.signals = existingSignals.signals || [];
-    existingSignals.signals.push(signal);
-
-    // 保留最近 100 条
-    if (existingSignals.signals.length > 100) {
-      existingSignals.signals = existingSignals.signals.slice(-100);
-    }
-
-    return mm.updateMemory(
-      MEMORY_SCOPE.PROJECT,
-      'evolution/signals.json',
-      existingSignals,
-      projectRoot
-    );
-  } catch (e) {
-    return false;
-  }
-}
-
-/**
- * 获取进化信号历史
- *
- * @param {string} projectRoot - 项目根目录
- * @param {number} limit - 返回数量限制
- * @returns {Array} 信号历史
- */
-export function getEvolutionSignalHistory(projectRoot, limit = 10) {
-  const mm = getMemoryManager();
-  if (!mm) {
-    return [];
-  }
-
-  try {
-    const signals = mm.getMemory(
-      MEMORY_SCOPE.PROJECT,
-      'evolution/signals.json',
-      projectRoot
-    );
-
-    if (signals && signals.signals) {
-      return signals.signals.slice(-limit);
-    }
-
-    return [];
-  } catch (e) {
-    return [];
-  }
-}
-
-/**
- * 清除进化信号
- *
- * @param {string} projectRoot - 项目根目录
- * @returns {boolean} 是否成功
- */
-export function clearEvolutionSignals(projectRoot) {
-  const mm = getMemoryManager();
-  if (!mm) {
-    return false;
-  }
-
-  try {
-    return mm.updateMemory(
-      MEMORY_SCOPE.PROJECT,
-      'evolution/signals.json',
-      { signals: [] },
-      projectRoot
-    );
-  } catch (e) {
-    return false;
-  }
-}
-
-/**
- * 检查是否应该触发进化
- *
- * @param {string} projectRoot - 项目根目录
- * @returns {Object} 检查结果 { shouldEvolve, reason, signals }
- */
-export function shouldTriggerEvolution(projectRoot) {
-  const { signals, shouldEvolve } = collectEvolutionSignals(projectRoot);
-
-  if (!shouldEvolve) {
-    return {
-      shouldEvolve: false,
-      reason: '未达到进化触发条件',
-      signals: []
-    };
-  }
-
-  // 确定触发原因
-  const signalTypes = signals.map(s => s.type);
-  let reason = '';
-
-  if (signalTypes.includes(EVOLUTION_SIGNAL_TYPES.FLOW_COMPLETE)) {
-    reason = '全流程已完成';
-  } else if (signalTypes.includes(EVOLUTION_SIGNAL_TYPES.SAME_PROBLEM_3TIMES)) {
-    reason = '同类问题出现3次';
-  } else if (signalTypes.includes(EVOLUTION_SIGNAL_TYPES.PRACTICE_LOG_5)) {
-    reason = '已有5条以上实践日志';
-  } else {
-    reason = '满足进化条件';
-  }
-
-  return {
-    shouldEvolve: true,
-    reason,
-    signals
-  };
-}
-
-export default {
-  EVOLUTION_SIGNAL_TYPES,
-  collectEvolutionSignals,
-  recordEvolutionSignal,
-  getEvolutionSignalHistory,
-  clearEvolutionSignals,
-  shouldTriggerEvolution
-};