@chongyan/autospec 1.0.1 → 1.0.3

package/plugins/hooks/memory-sync.js

@@ -1,171 +0,0 @@
-/**
- * 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

@@ -1,413 +0,0 @@
-#!/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);
-});