@chongyan/autospec 1.0.1

package/plugins/hooks/lib/memory-extractor.js

@@ -0,0 +1,377 @@
+/**
+ * Memory Extractor - 从对话中提取记忆
+ *
+ * 自动识别对话中的关键信息，写入对应的记忆层
+ */
+
+import {
+  MEMORY_SCOPE,
+  MEMORY_FILES
+} from '../../../scripts/install/constants.js';
+import {
+  getNorthStar,
+  updateNorthStar,
+  addKeyResult,
+  addActiveDecision,
+  getTeamPreferences,
+  updateTeamPreferences,
+  addHardConstraint,
+  getTechStack,
+  updateTechStack,
+  addArchitectureDecision,
+  addSession
+} from './memory-manager.js';
+
+/**
+ * 提取模式定义
+ */
+const EXTRACTION_PATTERNS = {
+  // 目标/指标相关 → 项目北极星
+  goals: [
+    { patterns: [/我们的目标是/, /项目目标/, /产品目标/], type: 'mission' },
+    { patterns: [/北极星指标/, /核心指标/, /关键指标/], type: 'northStarMetric' },
+    { patterns: [/关键结果/, /KR\d*/, /里程碑/], type: 'keyResult' },
+    { patterns: [/愿景/, /未来展望/, /长期目标/], type: 'vision' }
+  ],
+
+  // 偏好相关 → 全局/项目偏好
+  preferences: [
+    { patterns: [/我们偏好/, /我们喜欢/, /倾向于/], type: 'preference' },
+    { patterns: [/不要/, /禁止/, /不允许/, /不能/], type: 'constraint' },
+    { patterns: [/默认使用/, /默认配置/, /标准做法/], type: 'default' },
+    { patterns: [/风格/, /习惯/, /惯例/], type: 'style' }
+  ],
+
+  // 决策相关 → 项目架构记录
+  decisions: [
+    { patterns: [/决定采用/, /选择使用/, /选定/, /最终方案/], type: 'decision' },
+    { patterns: [/权衡后/, /综合考虑/, /对比之后/], type: 'tradeoff' },
+    { patterns: [/放弃/, /不采用/, /排除/], type: 'rejected' }
+  ],
+
+  // 技术栈相关 → 项目技术栈
+  techStack: [
+    { patterns: [/使用.*框架/, /技术栈/, /技术选型/], type: 'framework' },
+    { patterns: [/部署到/, /运行环境/, /基础设施/], type: 'environment' },
+    { patterns: [/依赖/, /库/, /包/], type: 'dependency' }
+  ]
+};
+
+/**
+ * 记忆提取结果类型
+ */
+const MEMORY_TYPES = {
+  MISSION: 'mission',
+  NORTH_STAR: 'northStar',
+  KEY_RESULT: 'keyResult',
+  VISION: 'vision',
+  PREFERENCE: 'preference',
+  CONSTRAINT: 'constraint',
+  DECISION: 'decision',
+  TECH_STACK: 'techStack',
+  SESSION_SUMMARY: 'sessionSummary'
+};
+
+/**
+ * 从文本中提取记忆
+ * @param {string} text - 对话文本
+ * @param {Object} context - 上下文信息
+ * @returns {Array<Object>} 提取的记忆列表
+ */
+export function extractFromText(text, context = {}) {
+  const extractions = [];
+
+  // 提取目标相关信息
+  EXTRACTION_PATTERNS.goals.forEach(({ patterns, type }) => {
+    patterns.forEach(pattern => {
+      const matches = text.matchAll(new RegExp(pattern.source, 'gi'));
+      for (const match of matches) {
+        // 获取匹配后的句子
+        const startIndex = match.index;
+        const endIndex = text.indexOf('。', startIndex);
+        const sentence = endIndex > startIndex
+          ? text.slice(startIndex, endIndex + 1)
+          : text.slice(startIndex, startIndex + 100);
+
+        extractions.push({
+          type: MEMORY_TYPES[type.toUpperCase()] || type,
+          content: sentence.trim(),
+          context: {
+            matched: match[0],
+            fullText: text.slice(Math.max(0, startIndex - 50), startIndex + 150)
+          },
+          confidence: 'medium',
+          source: 'conversation'
+        });
+      }
+    });
+  });
+
+  // 提取偏好相关信息
+  EXTRACTION_PATTERNS.preferences.forEach(({ patterns, type }) => {
+    patterns.forEach(pattern => {
+      const matches = text.matchAll(new RegExp(pattern.source, 'gi'));
+      for (const match of matches) {
+        const startIndex = match.index;
+        const endIndex = text.indexOf('。', startIndex);
+        const sentence = endIndex > startIndex
+          ? text.slice(startIndex, endIndex + 1)
+          : text.slice(startIndex, startIndex + 100);
+
+        extractions.push({
+          type: type === 'constraint' ? MEMORY_TYPES.CONSTRAINT : MEMORY_TYPES.PREFERENCE,
+          content: sentence.trim(),
+          context: {
+            matched: match[0],
+            fullText: text.slice(Math.max(0, startIndex - 50), startIndex + 150)
+          },
+          confidence: 'medium',
+          source: 'conversation'
+        });
+      }
+    });
+  });
+
+  // 提取决策相关信息
+  EXTRACTION_PATTERNS.decisions.forEach(({ patterns, type }) => {
+    patterns.forEach(pattern => {
+      const matches = text.matchAll(new RegExp(pattern.source, 'gi'));
+      for (const match of matches) {
+        const startIndex = match.index;
+        const endIndex = text.indexOf('。', startIndex);
+        const sentence = endIndex > startIndex
+          ? text.slice(startIndex, endIndex + 1)
+          : text.slice(startIndex, startIndex + 100);
+
+        extractions.push({
+          type: MEMORY_TYPES.DECISION,
+          content: sentence.trim(),
+          decisionType: type,
+          context: {
+            matched: match[0],
+            fullText: text.slice(Math.max(0, startIndex - 50), startIndex + 150)
+          },
+          confidence: 'high',
+          source: 'conversation'
+        });
+      }
+    });
+  });
+
+  // 去重
+  const uniqueExtractions = [];
+  const seen = new Set();
+  extractions.forEach(e => {
+    const key = `${e.type}:${e.content}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      uniqueExtractions.push(e);
+    }
+  });
+
+  return uniqueExtractions;
+}
+
+/**
+ * 将提取的记忆写入对应的存储
+ * @param {string} projectRoot - 项目根目录
+ * @param {Array<Object>} extractions - 提取的记忆列表
+ * @param {Object} options - 选项
+ * @returns {Object} 写入结果
+ */
+export function writeExtractions(projectRoot, extractions, options = {}) {
+  const results = {
+    success: [],
+    failed: [],
+    pending: []
+  };
+
+  const { autoConfirm = false, defaultScope = MEMORY_SCOPE.PROJECT } = options;
+
+  extractions.forEach(extraction => {
+    try {
+      switch (extraction.type) {
+        case MEMORY_TYPES.MISSION:
+        case MEMORY_TYPES.VISION:
+          // 更新北极星
+          const northStar = getNorthStar(projectRoot);
+          if (extraction.type === MEMORY_TYPES.MISSION) {
+            if (autoConfirm || !northStar.mission) {
+              updateNorthStar(projectRoot, { mission: extraction.content });
+              results.success.push({ ...extraction, action: 'updated', target: 'north-star.mission' });
+            } else {
+              results.pending.push({ ...extraction, reason: 'mission already exists' });
+            }
+          } else {
+            if (autoConfirm || !northStar.vision) {
+              updateNorthStar(projectRoot, { vision: extraction.content });
+              results.success.push({ ...extraction, action: 'updated', target: 'north-star.vision' });
+            } else {
+              results.pending.push({ ...extraction, reason: 'vision already exists' });
+            }
+          }
+          break;
+
+        case MEMORY_TYPES.KEY_RESULT:
+          // 添加关键结果
+          if (autoConfirm) {
+            addKeyResult(projectRoot, {
+              title: extraction.content,
+              current: '0%',
+              status: 'on-track'
+            });
+            results.success.push({ ...extraction, action: 'added', target: 'north-star.keyResults' });
+          } else {
+            results.pending.push({ ...extraction, reason: 'needs confirmation for key result' });
+          }
+          break;
+
+        case MEMORY_TYPES.PREFERENCE:
+          // 更新团队偏好（默认写入全局）
+          if (autoConfirm) {
+            updateTeamPreferences(MEMORY_SCOPE.GLOBAL, {
+              projectSpecific: {
+                [Date.now()]: extraction.content
+              }
+            });
+            results.success.push({ ...extraction, action: 'updated', target: 'global.team-preferences' });
+          } else {
+            results.pending.push({ ...extraction, reason: 'needs confirmation for preference' });
+          }
+          break;
+
+        case MEMORY_TYPES.CONSTRAINT:
+          // 添加约束（默认写入全局）
+          if (autoConfirm) {
+            addHardConstraint(MEMORY_SCOPE.GLOBAL, extraction.content);
+            results.success.push({ ...extraction, action: 'added', target: 'global.constraints' });
+          } else {
+            results.pending.push({ ...extraction, reason: 'needs confirmation for constraint' });
+          }
+          break;
+
+        case MEMORY_TYPES.DECISION:
+          // 添加架构决策
+          if (autoConfirm) {
+            addArchitectureDecision(projectRoot, {
+              title: extraction.content.slice(0, 50),
+              context: extraction.context?.fullText || '',
+              decision: extraction.content,
+              decisionType: extraction.decisionType
+            });
+            results.success.push({ ...extraction, action: 'added', target: 'project.architecture' });
+          } else {
+            results.pending.push({ ...extraction, reason: 'needs confirmation for decision' });
+          }
+          break;
+
+        case MEMORY_TYPES.TECH_STACK:
+          // 更新技术栈
+          if (autoConfirm) {
+            const techStack = getTechStack(projectRoot);
+            techStack.tools = techStack.tools || [];
+            techStack.tools.push({
+              name: extraction.content,
+              addedAt: new Date().toISOString(),
+              source: 'auto-extracted'
+            });
+            updateTechStack(projectRoot, techStack);
+            results.success.push({ ...extraction, action: 'updated', target: 'project.tech-stack' });
+          } else {
+            results.pending.push({ ...extraction, reason: 'needs confirmation for tech stack' });
+          }
+          break;
+
+        default:
+          results.pending.push({ ...extraction, reason: 'unknown memory type' });
+      }
+    } catch (error) {
+      results.failed.push({ ...extraction, error: error.message });
+    }
+  });
+
+  return results;
+}
+
+/**
+ * 从会话中提取并生成会话摘要
+ * @param {string} projectRoot - 项目根目录
+ * @param {Object} sessionInfo - 会话信息
+ * @returns {Object} 会话摘要
+ */
+export function extractSessionSummary(projectRoot, sessionInfo = {}) {
+  const { title = '', keyDecisions = [], keyFiles = [], summary = '' } = sessionInfo;
+
+  const session = {
+    title: title || `会话 ${new Date().toISOString().split('T')[0]}`,
+    summary,
+    keyDecisions,
+    keyFiles,
+    tags: extractTags(summary + ' ' + keyDecisions.join(' '))
+  };
+
+  addSession(projectRoot, session);
+
+  return session;
+}
+
+/**
+ * 从文本中提取标签
+ * @param {string} text - 文本
+ * @returns {Array<string>} 标签列表
+ */
+function extractTags(text) {
+  const tagPatterns = [
+    /架构|设计|重构/gi,
+    /测试|QA|质量/gi,
+    /性能|优化/gi,
+    /安全|漏洞/gi,
+    /部署|发布|交付/gi,
+    /需求|功能/gi,
+    /bug|修复/gi
+  ];
+
+  const tags = new Set();
+  tagPatterns.forEach(pattern => {
+    const matches = text.match(pattern);
+    if (matches) {
+      matches.forEach(m => tags.add(m.toLowerCase()));
+    }
+  });
+
+  return Array.from(tags).slice(0, 5);
+}
+
+/**
+ * 检查是否应该提取记忆
+ * @param {string} event - 事件类型
+ * @param {Object} data - 事件数据
+ * @returns {boolean} 是否应该提取
+ */
+export function shouldExtract(event, data = {}) {
+  // 会话结束时提取
+  if (event === 'Stop') {
+    return true;
+  }
+
+  // 阶段完成时提取
+  if (event === 'StageComplete') {
+    return true;
+  }
+
+  // 交付完成时提取
+  if (event === 'DeliveryComplete') {
+    return true;
+  }
+
+  return false;
+}
+
+export default {
+  extractFromText,
+  writeExtractions,
+  extractSessionSummary,
+  shouldExtract,
+  MEMORY_TYPES,
+  EXTRACTION_PATTERNS
+};