@chongyan/autospec 1.0.1

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

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

package/scripts/evolution/knowledge-loader.js

@@ -0,0 +1,346 @@
+/**
+ * Knowledge Loader - 知识加载器
+ *
+ * 实现三级优先级加载：项目 > 用户全局 > 组织
+ * 集成记忆模块的全局路径和双模式逻辑
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import {
+  GLOBAL_AUTOSPEC_DIR,
+  GLOBAL_AUTOSPEC_SUBDIRS,
+  ORG_AUTOSPEC_DIR,
+  ORG_AUTOSPEC_SUBDIRS,
+  KNOWLEDGE_SCOPE,
+  KNOWLEDGE_ZONES
+} from '../install/constants.js';
+
+// 缓存
+const knowledgeCache = new Map();
+const CACHE_TTL = 5000; // 5秒缓存
+
+/**
+ * 获取全局知识库根目录
+ * @returns {string} 全局知识库根目录
+ */
+export function getGlobalKnowledgeRoot() {
+  return path.join(os.homedir(), GLOBAL_AUTOSPEC_DIR);
+}
+
+/**
+ * 获取组织知识库根目录
+ * @param {string} orgName - 组织名称
+ * @returns {string} 组织知识库根目录
+ */
+export function getOrgKnowledgeRoot(orgName) {
+  return path.join(os.homedir(), ORG_AUTOSPEC_DIR, orgName);
+}
+
+/**
+ * 获取项目知识库根目录
+ * @param {string} projectRoot - 项目根目录
+ * @returns {string} 项目知识库根目录
+ */
+export function getProjectKnowledgeRoot(projectRoot) {
+  return path.join(projectRoot, '.autospec');
+}
+
+/**
+ * 解析知识文件路径
+ * @param {string} scope - 作用域 (global|org|project)
+ * @param {string} type - 知识类型 (knowledge|skills|roles|environment)
+ * @param {string} name - 知识名称
+ * @param {Object} options - 选项
+ * @returns {string} 完整文件路径
+ */
+export function resolveKnowledgePath(scope, type, name, options = {}) {
+  const { projectRoot = '.', orgName = null } = options;
+
+  switch (scope) {
+    case KNOWLEDGE_SCOPE.GLOBAL:
+      return path.join(getGlobalKnowledgeRoot(), GLOBAL_AUTOSPEC_SUBDIRS[type.toUpperCase()] || type, name);
+
+    case KNOWLEDGE_SCOPE.ORG:
+      if (!orgName) {
+        throw new Error('orgName is required for org scope');
+      }
+      return path.join(getOrgKnowledgeRoot(orgName), ORG_AUTOSPEC_SUBDIRS[type.toUpperCase()] || type, name);
+
+    case KNOWLEDGE_SCOPE.PROJECT:
+    default:
+      return path.join(getProjectKnowledgeRoot(projectRoot), type, name);
+  }
+}
+
+/**
+ * 安全地读取文件
+ * @param {string} filePath - 文件路径
+ * @returns {string|null} 文件内容
+ */
+function safeReadFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    return fs.readFileSync(filePath, 'utf-8');
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * 安全地读取 JSON 文件
+ * @param {string} filePath - 文件路径
+ * @param {any} defaultValue - 默认值
+ * @returns {any} 解析后的数据
+ */
+function safeReadJson(filePath, defaultValue = null) {
+  try {
+    const content = safeReadFile(filePath);
+    if (!content) {
+      return defaultValue;
+    }
+    return JSON.parse(content);
+  } catch (e) {
+    return defaultValue;
+  }
+}
+
+/**
+ * 获取知识缓存键
+ * @param {string} scope - 作用域
+ * @param {string} type - 类型
+ * @param {string} name - 名称
+ * @returns {string} 缓存键
+ */
+function getCacheKey(scope, type, name) {
+  return `${scope}:${type}:${name}`;
+}
+
+/**
+ * 加载知识（带缓存）
+ * @param {string} scope - 作用域
+ * @param {string} type - 类型
+ * @param {string} name - 名称
+ * @param {Object} options - 选项
+ * @returns {Object|null} 知识内容
+ */
+export function loadKnowledge(scope, type, name, options = {}) {
+  const { useCache = true, projectRoot = '.', orgName = null } = options;
+  const cacheKey = getCacheKey(scope, type, name);
+
+  if (useCache) {
+    const cached = knowledgeCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+      return cached.data;
+    }
+  }
+
+  const filePath = resolveKnowledgePath(scope, type, name, { projectRoot, orgName });
+  const content = safeReadFile(filePath);
+
+  if (content && useCache) {
+    knowledgeCache.set(cacheKey, { data: content, timestamp: Date.now() });
+  }
+
+  return content;
+}
+
+/**
+ * 加载知识 JSON（带缓存）
+ * @param {string} scope - 作用域
+ * @param {string} type - 类型
+ * @param {string} name - 名称
+ * @param {Object} options - 选项
+ * @returns {any} 知识内容
+ */
+export function loadKnowledgeJson(scope, type, name, options = {}) {
+  const { useCache = true, projectRoot = '.', orgName = null } = options;
+  const cacheKey = `json:${getCacheKey(scope, type, name)}`;
+
+  if (useCache) {
+    const cached = knowledgeCache.get(cacheKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+      return cached.data;
+    }
+  }
+
+  const filePath = resolveKnowledgePath(scope, type, name, { projectRoot, orgName });
+  const data = safeReadJson(filePath, null);
+
+  if (data && useCache) {
+    knowledgeCache.set(cacheKey, { data, timestamp: Date.now() });
+  }
+
+  return data;
+}
+
+/**
+ * 三级优先级加载知识
+ * 优先级：项目 > 用户全局 > 组织
+ *
+ * @param {string} type - 知识类型
+ * @param {string} name - 知识名称
+ * @param {Object} options - 选项
+ * @returns {Object} 加载结果 { content, scope, path }
+ */
+export function loadKnowledgeWithFallback(type, name, options = {}) {
+  const { projectRoot = '.', orgName = null, preferScope = null } = options;
+
+  // 如果指定了偏好作用域，优先尝试
+  if (preferScope) {
+    const content = loadKnowledge(preferScope, type, name, { projectRoot, orgName });
+    if (content) {
+      return {
+        content,
+        scope: preferScope,
+        path: resolveKnowledgePath(preferScope, type, name, { projectRoot, orgName })
+      };
+    }
+  }
+
+  // 1. 优先加载项目知识
+  const projectContent = loadKnowledge(KNOWLEDGE_SCOPE.PROJECT, type, name, { projectRoot });
+  if (projectContent) {
+    return {
+      content: projectContent,
+      scope: KNOWLEDGE_SCOPE.PROJECT,
+      path: resolveKnowledgePath(KNOWLEDGE_SCOPE.PROJECT, type, name, { projectRoot })
+    };
+  }
+
+  // 2. 回退到全局知识
+  const globalContent = loadKnowledge(KNOWLEDGE_SCOPE.GLOBAL, type, name, { projectRoot });
+  if (globalContent) {
+    return {
+      content: globalContent,
+      scope: KNOWLEDGE_SCOPE.GLOBAL,
+      path: resolveKnowledgePath(KNOWLEDGE_SCOPE.GLOBAL, type, name, { projectRoot })
+    };
+  }
+
+  // 3. 最后回退到组织知识
+  if (orgName) {
+    const orgContent = loadKnowledge(KNOWLEDGE_SCOPE.ORG, type, name, { projectRoot, orgName });
+    if (orgContent) {
+      return {
+        content: orgContent,
+        scope: KNOWLEDGE_SCOPE.ORG,
+        path: resolveKnowledgePath(KNOWLEDGE_SCOPE.ORG, type, name, { projectRoot, orgName })
+      };
+    }
+  }
+
+  return { content: null, scope: null, path: null };
+}
+
+/**
+ * 加载技能（带版本支持）
+ * @param {string} skillName - 技能名称
+ * @param {Object} options - 选项
+ * @returns {Object} 技能内容
+ */
+export function loadSkill(skillName, options = {}) {
+  const { version = 'latest', projectRoot = '.', orgName = null } = options;
+
+  // 尝试加载指定版本
+  if (version !== 'latest') {
+    const versionedResult = loadKnowledgeWithFallback('skills', `${skillName}/v${version}/SKILL.md`, options);
+    if (versionedResult.content) {
+      return versionedResult;
+    }
+  }
+
+  // 尝试加载最新版本
+  const latestResult = loadKnowledgeWithFallback('skills', `${skillName}/SKILL.md`, options);
+  if (latestResult.content) {
+    return latestResult;
+  }
+
+  // 尝试从 plugins 源码加载
+  const sourcePath = path.join(process.cwd(), 'plugins', 'skills', skillName, 'SKILL.md');
+  const sourceContent = safeReadFile(sourcePath);
+  if (sourceContent) {
+    return {
+      content: sourceContent,
+      scope: 'source',
+      path: sourcePath
+    };
+  }
+
+  return { content: null, scope: null, path: null };
+}
+
+/**
+ * 获取知识分区
+ * @param {string} knowledgePath - 知识路径
+ * @returns {string} 知识分区
+ */
+export function getKnowledgeZone(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} scope - 作用域
+ * @param {string} type - 类型
+ * @param {string} name - 名称
+ * @param {Object} options - 选项
+ * @returns {boolean} 是否存在
+ */
+export function knowledgeExists(scope, type, name, options = {}) {
+  const { projectRoot = '.', orgName = null } = options;
+  const filePath = resolveKnowledgePath(scope, type, name, { projectRoot, orgName });
+  return fs.existsSync(filePath);
+}
+
+/**
+ * 清除知识缓存
+ * @param {string} scope - 作用域（可选）
+ */
+export function clearKnowledgeCache(scope = null) {
+  if (scope) {
+    for (const key of knowledgeCache.keys()) {
+      if (key.startsWith(`${scope}:`)) {
+        knowledgeCache.delete(key);
+      }
+    }
+  } else {
+    knowledgeCache.clear();
+  }
+}
+
+export default {
+  // 路径解析
+  getGlobalKnowledgeRoot,
+  getOrgKnowledgeRoot,
+  getProjectKnowledgeRoot,
+  resolveKnowledgePath,
+  // 加载
+  loadKnowledge,
+  loadKnowledgeJson,
+  loadKnowledgeWithFallback,
+  loadSkill,
+  // 工具
+  getKnowledgeZone,
+  knowledgeExists,
+  clearKnowledgeCache
+};