@chongyan/autospec 1.0.1

package/plugins/hooks/memory-sync.js

@@ -0,0 +1,171 @@
+/**
+ * Memory Sync Hook - 会话结束时同步记忆
+ *
+ * 触发时机：Stop 事件
+ * 功能：
+ * 1. 从对话中提取记忆
+ * 2. 更新工作记忆
+ * 3. 生成会话摘要
+ * 4. 触发记忆 GC（如果需要）
+ */
+
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { extractFromText, writeExtractions, extractSessionSummary, shouldExtract } from './lib/memory-extractor.js';
+import {
+  hasGlobalMemory,
+  hasProjectMemory,
+  initGlobalMemory,
+  initProjectMemory,
+  updateCurrentContext,
+  clearCurrentContext,
+  updateMemory
+} from './lib/memory-manager.js';
+import { MEMORY_FILES, MEMORY_SCOPE } from '../scripts/install/constants.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 查找项目根目录
+ * @returns {string|null} 项目根目录
+ */
+function findProjectRoot() {
+  let currentDir = process.cwd();
+
+  for (let i = 0; i < 10; i++) {
+    if (path.basename(currentDir) === '.autospec') {
+      return path.dirname(currentDir);
+    }
+
+    const autospecDir = path.join(currentDir, '.autospec');
+    if (require('fs').existsSync(autospecDir)) {
+      return currentDir;
+    }
+
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir) {
+      break;
+    }
+    currentDir = parentDir;
+  }
+
+  return null;
+}
+
+/**
+ * 记忆同步主函数
+ * @param {Object} context - Hook 上下文
+ */
+export async function main(context = {}) {
+  const projectRoot = findProjectRoot();
+
+  if (!projectRoot) {
+    // 不在 AutoSpec 项目中，静默退出
+    return {
+      status: 'skipped',
+      reason: 'not_in_autospec_project'
+    };
+  }
+
+  const results = {
+    timestamp: new Date().toISOString(),
+    projectRoot,
+    actions: []
+  };
+
+  try {
+    // 1. 确保记忆系统已初始化
+    if (!hasGlobalMemory()) {
+      initGlobalMemory();
+      results.actions.push({ action: 'init_global_memory', status: 'success' });
+    }
+
+    if (!hasProjectMemory(projectRoot)) {
+      initProjectMemory(projectRoot);
+      results.actions.push({ action: 'init_project_memory', status: 'success' });
+    }
+
+    // 2. 从对话中提取记忆（如果有对话内容）
+    if (context.conversationText || context.messages) {
+      const text = context.conversationText ||
+        (context.messages || []).map(m => m.content || '').join('\n');
+
+      if (text && text.length > 100) {
+        const extractions = extractFromText(text, context);
+
+        if (extractions.length > 0) {
+          const writeResults = writeExtractions(projectRoot, extractions, {
+            autoConfirm: false // 默认需要用户确认
+          });
+
+          results.actions.push({
+            action: 'extract_memories',
+            status: 'success',
+            extracted: extractions.length,
+            written: writeResults.success.length,
+            pending: writeResults.pending.length,
+            failed: writeResults.failed.length
+          });
+
+          // 如果有待确认的记忆，记录到 memory-meta.json
+          if (writeResults.pending.length > 0) {
+            updateMemory(MEMORY_SCOPE.PROJECT, MEMORY_FILES.MEMORY_META, {
+              pendingExtractions: writeResults.pending
+            }, projectRoot);
+          }
+        }
+      }
+    }
+
+    // 3. 生成会话摘要（如果有会话信息）
+    if (context.sessionInfo) {
+      const sessionSummary = extractSessionSummary(projectRoot, context.sessionInfo);
+      results.actions.push({
+        action: 'session_summary',
+        status: 'success',
+        sessionId: sessionSummary.id
+      });
+    }
+
+    // 4. 更新记忆元数据统计
+    updateMemory(MEMORY_SCOPE.PROJECT, MEMORY_FILES.MEMORY_META, {
+      lastSessionDate: new Date().toISOString(),
+      'statistics.totalSessions': (prev => (prev || 0) + 1)
+    }, projectRoot);
+
+    // 5. 清理工作记忆（可选）
+    if (context.clearWorkingMemory) {
+      clearCurrentContext(projectRoot);
+      results.actions.push({ action: 'clear_working_memory', status: 'success' });
+    }
+
+    return {
+      status: 'success',
+      ...results
+    };
+
+  } catch (error) {
+    console.error('[AutoSpec memory-sync] 同步失败:', error.message);
+    return {
+      status: 'error',
+      error: error.message,
+      ...results
+    };
+  }
+}
+
+// 如果直接运行此脚本
+if (process.argv[1] === __filename) {
+  main({
+    conversationText: process.env.AUTOSPEC_CONVERSATION || '',
+    sessionInfo: process.env.AUTOSPEC_SESSION_INFO ? JSON.parse(process.env.AUTOSPEC_SESSION_INFO) : null
+  }).then(result => {
+    console.log(JSON.stringify(result, null, 2));
+  }).catch(error => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+
+export default { main };

package/plugins/hooks/pipeline-observer.js

@@ -0,0 +1,413 @@
+#!/usr/bin/env node
+
+/**
+ * AutoSpec Hook: Pipeline Observer
+ *
+ * 全链路事件采集和分析 Hook
+ * - PostToolUse: 采集标准化事件
+ * - Stop: 生成评测报告
+ *
+ * 职责：
+ * 1. 采集标准化事件
+ * 2. 实时计算指标
+ * 3. 检测异常模式
+ * 4. Stop 时触发评测报告生成
+ */
+
+import { createHookLogger, safeJsonParse, handleHookError, readStdin, findProjectRootAsync } from './lib/hook-logger.js';
+import { getState, getMetrics, updateMetrics } from './lib/hook-state-manager.js';
+import { getTraceId, recordEvent } from './lib/trace-context.js';
+import { recordPathEvent, recordTool, recordDecision, PATH_EVENT_TYPES } from './lib/execution-path.js';
+import { calculateFrameworkQualityScore, detectErrorPatterns } from './lib/metrics-analyzer.js';
+
+const logger = createHookLogger('pipeline-observer');
+
+/**
+ * PostToolUse 处理
+ */
+async function handlePostToolUse(input, projectRoot) {
+  const toolName = input.tool_name;
+  const toolInput = input.tool_input || {};
+  const response = input.tool_response || {};
+
+  // 记录工具调用到执行路径
+  recordTool(projectRoot, toolName, detectAction(toolName, toolInput));
+
+  // 采集特定事件
+  switch (toolName) {
+    case 'AskUserQuestion':
+      handleUserQuestion(projectRoot, toolInput, response);
+      break;
+
+    case 'Agent':
+      handleAgentCall(projectRoot, toolInput, response);
+      break;
+
+    case 'Bash':
+      handleBashCommand(projectRoot, toolInput, response);
+      break;
+  }
+
+  // 实时检测异常模式
+  checkAnomalies(projectRoot);
+}
+
+/**
+ * Stop 处理：生成评测报告 + 自动触发一致性检测
+ */
+async function handleStop(projectRoot) {
+  logger.info('Session ending, generating evaluation report');
+
+  // 计算质量分数
+  const qualityScore = calculateFrameworkQualityScore(projectRoot);
+
+  // 检测错误模式
+  const errorPatterns = detectErrorPatterns(getMetrics(projectRoot, false));
+
+  // 更新 metrics.json
+  const metrics = getMetrics(projectRoot, false);
+  metrics.qualityScore = qualityScore;
+  metrics.errorPatterns = errorPatterns;
+  metrics.pipelineEnd = new Date().toISOString();
+
+  updateMetrics(projectRoot, metrics);
+
+  // 记录事件
+  const traceId = getTraceId(projectRoot);
+  if (traceId) {
+    recordEvent(projectRoot, 'pipeline_end', {
+      source: 'pipeline-observer',
+      action: 'generate_evaluation',
+       data: {
+        qualityScore: qualityScore.overall,
+        errorPatternCount: errorPatterns.length
+      }
+    });
+  }
+
+  // 自动触发一致性检测（如果有多个产出物）
+  const consistencyResult = await autoTriggerConsistencyCheck(projectRoot, metrics);
+
+  // 输出评测摘要
+  outputEvaluationSummary(qualityScore, errorPatterns, consistencyResult);
+}
+
+/**
+ * 自动触发一致性检测
+ */
+async function autoTriggerConsistencyCheck(projectRoot, metrics) {
+  const artifacts = metrics?.artifacts || {};
+  const artifactPaths = Object.keys(artifacts);
+
+  // 如果有 2 个以上产出物，触发一致性检测
+  if (artifactPaths.length < 2) {
+    return null;
+  }
+
+  logger.info('Auto-triggering consistency check', { artifactCount: artifactPaths.length });
+
+  // 记录一致性检测触发事件
+  const traceId = getTraceId(projectRoot);
+  if (traceId) {
+    recordEvent(projectRoot, 'consistency_check_triggered', {
+      source: 'pipeline-observer',
+      action: 'auto_consistency_check',
+       data: {
+        artifactCount: artifactPaths.length,
+        artifacts: artifactPaths
+      }
+    });
+  }
+
+  // 返回一致性检测提示
+  return {
+    triggered: true,
+    artifactCount: artifactPaths.length,
+    message: `
+[AutoSpec] 自动触发一致性检测
+
+检测到 ${artifactPaths.length} 个产出物，建议执行一致性分析：
+- 需求→设计 覆盖检查
+- 设计→实现 覆盖检查
+- 术语一致性检查
+
+详细评测请执行: /autospec:evaluate
+`
+  };
+}
+
+/**
+ * 处理用户问题
+ */
+function handleUserQuestion(projectRoot, toolInput, response) {
+  const questions = toolInput.questions || [];
+
+  // 记录决策点
+  recordDecision(projectRoot, 'human', {
+    questionCount: questions.length,
+    questionTypes: questions.map(q => q.header || 'unknown')
+  });
+
+  // 记录事件
+  const traceId = getTraceId(projectRoot);
+  if (traceId) {
+    recordEvent(projectRoot, 'human_intervention', {
+      source: 'pipeline-observer',
+      tool: 'AskUserQuestion',
+      action: 'ask_user',
+       data: {
+        questionCount: questions.length,
+        questions: questions.map(q => ({ header: q.header, question: q.question }))
+      }
+    });
+  }
+}
+
+/**
+ * 处理 Agent 调用
+ */
+function handleAgentCall(projectRoot, toolInput, response) {
+  const subagentType = toolInput.subagent_type || 'unknown';
+
+  // 记录决策点（Agent 调用通常是自动决策）
+  recordDecision(projectRoot, 'auto', {
+    agentType: subagentType
+  });
+
+  // 记录事件
+  const traceId = getTraceId(projectRoot);
+  if (traceId) {
+    const success = !response.error;
+    recordEvent(projectRoot, success ? 'agent_success' : 'agent_fail', {
+      source: 'pipeline-observer',
+      tool: 'Agent',
+      action: 'call_agent',
+       data: {
+        subagentType,
+        success
+      }
+    });
+  }
+}
+
+/**
+ * 处理 Bash 命令
+ */
+function handleBashCommand(projectRoot, toolInput, response) {
+  const command = toolInput.command || '';
+
+  // 检测命令类型
+  const commandType = detectCommandType(command);
+
+  if (commandType) {
+    const traceId = getTraceId(projectRoot);
+    if (traceId) {
+      const success = response.exitCode === 0;
+      recordEvent(projectRoot, success ? 'command_success' : 'command_fail', {
+        source: 'pipeline-observer',
+        tool: 'Bash',
+        action: commandType,
+        data: {
+          command: command.substring(0, 100),
+          exitCode: response.exitCode
+        }
+      });
+    }
+  }
+}
+
+/**
+ * 检测工具动作
+ */
+function detectAction(toolName, toolInput) {
+  switch (toolName) {
+    case 'Read':
+      return 'read_file';
+    case 'Write':
+      return 'write_file';
+    case 'Edit':
+      return 'edit_file';
+    case 'Bash':
+      return 'run_command';
+    case 'Agent':
+      return `call_${toolInput.subagent_type || 'agent'}`;
+    case 'AskUserQuestion':
+      return 'ask_user';
+    default:
+      return 'unknown';
+  }
+}
+
+/**
+ * 检测命令类型
+ */
+function detectCommandType(command) {
+  if (/npm\s+(test|run\s+test)/.test(command)) return 'test';
+  if (/npm\s+(run\s+)?build/.test(command)) return 'build';
+  if (/npm\s+run\s+lint/.test(command)) return 'lint';
+  if (/pytest|jest|mocha/.test(command)) return 'test';
+  if (/tsc|typescript/.test(command)) return 'typecheck';
+  return null;
+}
+
+/**
+ * 检测异常模式
+ */
+function checkAnomalies(projectRoot) {
+  const metrics = getMetrics(projectRoot, true);
+
+  // 检测连续失败
+  const recentErrors = (metrics?.totals?.errors || []).slice(-5);
+  if (recentErrors.length >= 3) {
+    const timeWindow = 5 * 60 * 1000; // 5 分钟
+    const now = Date.now();
+    const recentFailures = recentErrors.filter(e =>
+      now - new Date(e.time).getTime() < timeWindow
+    );
+
+    if (recentFailures.length >= 3) {
+      // 触发自动诊断建议
+      outputAnomalyWarning('consecutive_failures', {
+        count: recentFailures.length,
+        timeWindow: '5min',
+        suggestion: '短时间内多次失败，建议暂停检查环境配置',
+        requiredAction: '建议暂停当前流程，执行诊断后再继续',
+        diagnosisCommand: '读取 framework/skills/support/ai-anomaly-analyzer.md 获取诊断建议'
+      });
+    }
+  }
+
+  // 检测 Layer1 连续失败
+  const layer1Fails = (metrics?.totals?.errors || []).filter(e => e.type === 'layer1_fail');
+  if (layer1Fails.length >= 3) {
+    outputAnomalyWarning('layer1_consecutive_failures', {
+      count: layer1Fails.length,
+      suggestion: 'Layer1 验证连续失败，可能存在系统性问题',
+      requiredAction: '建议检查：1) 测试依赖是否就绪 2) 代码实现是否符合设计 3) 环境配置是否正确'
+    });
+  }
+}
+
+/**
+ * 输出异常告警
+ */
+function outputAnomalyWarning(type, details) {
+  const message = `
+[AutoSpec Anomaly Warning] 检测到异常模式
+
+类型: ${type}
+详情: ${JSON.stringify(details, null, 2)}
+
+建议: ${details.suggestion}
+${details.requiredAction ? `\n**建议操作**: ${details.requiredAction}` : ''}
+${details.diagnosisCommand ? `\n诊断: ${details.diagnosisCommand}` : ''}
+`;
+
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'PostToolUse',
+      additionalContext: message
+    }
+  }));
+}
+
+/**
+ * 输出评测摘要
+ */
+function outputEvaluationSummary(qualityScore, errorPatterns, consistencyResult = null) {
+  const gradeEmoji = {
+    'A': '🟢',
+    'B': '🟡',
+    'C': '🟠',
+    'D': '🔴',
+    'F': '⚫'
+  };
+
+  const emoji = gradeEmoji[qualityScore.grade] || '⚪';
+
+  let summary = `
+[AutoSpec Evaluation Summary] ${emoji}
+
+## 质量评分
+- 综合评分: ${qualityScore.overall}/100 (${qualityScore.grade})
+- 过程指标: ${qualityScore.breakdown.process.score}/100
+- 结果指标: ${qualityScore.breakdown.result.score}/100
+- 路径指标: ${qualityScore.breakdown.path.score}/100
+
+## 错误模式
+${errorPatterns.length > 0
+  ? errorPatterns.map(p => `- [${p.severity}] ${p.suggestion}`).join('\n')
+  : '- 无显著错误模式'
+}
+
+${consistencyResult?.message || ''}
+`;
+
+  // 低分时输出强制建议
+  if (qualityScore.overall < 70) {
+    summary += `
+## ⚠️ 质量告警
+
+综合评分低于 70 分，建议：
+1. 执行 /autospec:evaluate 获取详细评测报告
+2. 检查流程执行情况，优化低分维度
+3. 如有进化触发，执行 /autospec:evolve
+`;
+  } else {
+    summary += `
+## 建议
+流程执行良好，继续保持。
+
+详细报告请执行: /autospec:evaluate
+`;
+  }
+
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'Stop',
+      additionalContext: summary
+    }
+  }));
+}
+
+async function main() {
+  let input;
+  try {
+    const rawInput = await readStdin(1000);
+    input = safeJsonParse(rawInput, null, 'hook input');
+
+    if (!input) {
+      logger.debug('Empty or invalid input, skipping');
+      process.exit(0);
+    }
+  } catch (err) {
+    logger.error('Failed to parse input', { error: err.message });
+    process.exit(0);
+  }
+
+  const cwd = input.cwd || process.cwd();
+  const projectRoot = await findProjectRootAsync(cwd);
+
+  if (!projectRoot) {
+    logger.debug('No .autospec directory found, skipping');
+    process.exit(0);
+  }
+
+  const eventName = input.event_name;
+
+  if (eventName === 'PostToolUse') {
+    await handlePostToolUse(input, projectRoot);
+  } else if (eventName === 'Stop') {
+    await handleStop(projectRoot);
+  }
+
+  process.exit(0);
+}
+
+main().catch((err) => {
+  const result = handleHookError('pipeline-observer', err, {
+    eventName: 'PostToolUse'
+  });
+  process.stdout.write(JSON.stringify(result.hookSpecificOutput));
+  process.exit(0);
+});