@chongyan/autospec 1.0.2 → 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/monitoring-trigger.js

@@ -1,467 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * AutoSpec Hook: Monitoring Trigger
- *
- * 后台监控触发器 Hook，负责：
- * 1. 累积代码变更计数
- * 2. 根据复杂度权衡触发后台监控检查
- * 3. 输出监控提醒到主上下文
- *
- * Security Level: LOW - fail-open + logging
- */
-
-import { createHookLogger, safeJsonParse, handleHookError, readStdin, findProjectRootAsync } from './lib/hook-logger.js';
-import { recordHookExecution } from './lib/hook-error-recorder.js';
-import { getState, getCurrentStageSubsystems } from './lib/hook-state-manager.js';
-import fs from 'fs';
-import path from 'path';
-
-const logger = createHookLogger('monitoring-trigger');
-
-// 监控触发配置
-const MONITORING_CONFIG = {
-  highComplexity: {
-    interval: 5 * 60 * 1000, // 5 分钟
-    threshold: 1, // 1 次变更触发
-    checkDepth: 'deep'
-  },
-  mediumComplexity: {
-    interval: 10 * 60 * 1000, // 10 分钟
-    threshold: 3, // 3 次变更触发
-    checkDepth: 'medium'
-  },
-  lowComplexity: {
-    interval: 20 * 60 * 1000, // 20 分钟
-    threshold: 5, // 5 次变更触发
-    checkDepth: 'light'
-  }
-};
-
-// 变更累积文件
-function getChangeCounterPath(projectRoot) {
-  return path.join(projectRoot, '.autospec', 'runtime', 'change-counter.json');
-}
-
-// 最后检查时间文件
-function getLastCheckPath(projectRoot) {
-  return path.join(projectRoot, '.autospec', 'runtime', 'last-check.json');
-}
-
-/**
- * 读取变更计数器
- */
-function readChangeCounter(projectRoot) {
-  const counterPath = getChangeCounterPath(projectRoot);
-  if (fs.existsSync(counterPath)) {
-    try {
-      return JSON.parse(fs.readFileSync(counterPath, 'utf-8'));
-    } catch {
-      return { total: 0, bySubsystem: {}, lastChangeAt: null };
-    }
-  }
-  return { total: 0, bySubsystem: {}, lastChangeAt: null };
-}
-
-/**
- * 写入变更计数器
- */
-function writeChangeCounter(projectRoot, counter) {
-  const counterPath = getChangeCounterPath(projectRoot);
-  const dir = path.dirname(counterPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(counterPath, JSON.stringify(counter, null, 2), 'utf-8');
-}
-
-/**
- * 读取最后检查时间
- */
-function readLastCheck(projectRoot) {
-  const lastCheckPath = getLastCheckPath(projectRoot);
-  if (fs.existsSync(lastCheckPath)) {
-    try {
-      return JSON.parse(fs.readFileSync(lastCheckPath, 'utf-8'));
-    } catch {
-      return { lastCheckAt: null, lastCheckType: null };
-    }
-  }
-  return { lastCheckAt: null, lastCheckType: null };
-}
-
-/**
- * 写入最后检查时间
- */
-function writeLastCheck(projectRoot, checkInfo) {
-  const lastCheckPath = getLastCheckPath(projectRoot);
-  const dir = path.dirname(lastCheckPath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(lastCheckPath, JSON.stringify(checkInfo, null, 2), 'utf-8');
-}
-
-/**
- * 获取任务复杂度
- */
-function getComplexity(state) {
-  // 从 state 中读取复杂度评估
-  // 如果没有，默认为中等复杂度
-  return state?.complexity || 'medium';
-}
-
-/**
- * 检测子系统变更
- */
-function detectSubsystemChange(filePath, subsystems) {
-  if (!filePath || !subsystems || subsystems.length === 0) {
-    return null;
-  }
-
-  const relativePath = filePath.replace(process.cwd() + '/', '').replace(process.cwd() + '\\', '');
-
-  for (const sub of subsystems) {
-    if (relativePath.startsWith(sub.path + '/') ||
-        relativePath.startsWith(sub.path + '\\') ||
-        relativePath.startsWith(sub.name + '/')) {
-      return sub.name;
-    }
-  }
-
-  return null;
-}
-
-/**
- * 检查是否需要触发监控
- */
-function shouldTriggerMonitoring(counter, lastCheck, complexity) {
-  const config = MONITORING_CONFIG[complexity] || MONITORING_CONFIG.mediumComplexity;
-  const now = Date.now();
-
-  // 检查时间间隔
-  const timeSinceLastCheck = lastCheck.lastCheckAt ? now - new Date(lastCheck.lastCheckAt).getTime() : Infinity;
-  const timeThresholdReached = timeSinceLastCheck >= config.interval;
-
-  // 检查变更阈值
-  const changeThresholdReached = counter.total >= config.threshold;
-
-  // 时间和变更阈值都达到时才触发
-  return timeThresholdReached && changeThresholdReached;
-}
-
-/**
- * 触发监控检查
- */
-async function triggerMonitoring(projectRoot, complexity) {
-  try {
-    logger.info('Triggering monitoring check', { complexity });
-
-    // 记录最后检查时间
-    writeLastCheck(projectRoot, {
-      lastCheckAt: new Date().toISOString(),
-      lastCheckType: 'monitoring',
-      complexity
-    });
-
-    // 重置变更计数器
-    writeChangeCounter(projectRoot, { total: 0, bySubsystem: {}, lastChangeAt: null });
-
-    // 执行实际的监控检查
-    const alerts = await executeMonitoringCheck(projectRoot, complexity);
-
-    // 输出提醒（如果有）
-    if (alerts && alerts.length > 0) {
-      outputMonitoringAlert(projectRoot, alerts);
-    }
-
-    return true;
-  } catch (e) {
-    logger.error('Failed to trigger monitoring', { error: e.message });
-    return false;
-  }
-}
-
-/**
- * 执行监控检查（调用 checker 脚本）
- */
-async function executeMonitoringCheck(projectRoot, complexity) {
-  const alerts = [];
-
-  try {
-    // 1. 读取 state 获取子系统列表
-    const state = getState(projectRoot, true);
-    const subsystems = getCurrentStageSubsystems(projectRoot);
-
-    if (subsystems.length === 0) {
-      // 单系统模式，不执行深度检查
-      return alerts;
-    }
-
-    // 2. 调用子系统覆盖检查
-    const { generateCoverageReport } = await import('../skills/project-evolve-scanner/scripts/subsystem-coverage.js');
-    const coverageReport = generateCoverageReport({
-      projectRoot,
-      state,
-      designSubsystems: subsystems
-    });
-
-    // 3. 检查子系统覆盖问题
-    if (coverageReport.summary.pending > 0) {
-      const pendingSubsystems = coverageReport.subsystems
-        .filter(s => s.status === 'pending')
-        .map(s => s.name);
-
-      alerts.push({
-        severity: coverageReport.summary.pending >= 2 ? 'high' : 'medium',
-        title: '子系统未开始实现',
-        description: `检测到 ${coverageReport.summary.pending} 个子系统尚未开始：${pendingSubsystems.join(', ')}`,
-        suggestion: '检查开发顺序依赖，确认是否需要优先处理某些子系统'
-      });
-    }
-
-    // 4. 检查 Layer 1 验证状态
-    const pendingLayer1 = coverageReport.subsystems
-      .filter(s => s.status === 'completed' && !s.layer1)
-      .map(s => s.name);
-
-    if (pendingLayer1.length > 0) {
-      alerts.push({
-        severity: 'high',
-        title: '子系统未执行 Layer 1 验证',
-        description: `检测到 ${pendingLayer1.length} 个子系统已完成但未执行验证：${pendingLayer1.join(', ')}`,
-        suggestion: '执行 build/test/lint 验证后再标记为完成'
-      });
-    }
-
-    // 5. 检查监控问题修复情况
-    const monitoringIssuesPath = path.join(projectRoot, '.autospec', 'monitoring-issues.json');
-    if (fs.existsSync(monitoringIssuesPath)) {
-      try {
-        const issues = JSON.parse(fs.readFileSync(monitoringIssuesPath, 'utf-8'));
-        const openIssues = issues.filter(i => i.status === 'open' || i.status === 'acknowledged');
-
-        if (openIssues.length > 0) {
-          const criticalIssues = openIssues.filter(i => i.severity === 'critical' || i.severity === 'high');
-          if (criticalIssues.length > 0) {
-            alerts.push({
-              severity: 'critical',
-              title: '存在未解决的高优先级监控问题',
-              description: `检测到 ${criticalIssues.length} 个高优先级问题未解决`,
-              suggestion: `查看详情：.autospec/monitoring-issues.json`,
-              issues: criticalIssues.map(i => ({ id: i.id, title: i.title, severity: i.severity }))
-            });
-          }
-        }
-      } catch (e) {
-        logger.debug('Failed to read monitoring issues', { error: e.message });
-      }
-    }
-
-    // 6. 写入监控报告
-    const reportPath = path.join(projectRoot, '.autospec', 'monitoring-report.md');
-    const reportDir = path.dirname(reportPath);
-    if (!fs.existsSync(reportDir)) {
-      fs.mkdirSync(reportDir, { recursive: true });
-    }
-
-    let reportContent = `# AutoSpec 监控报告\n\n`;
-    reportContent += `**检查时间**: ${new Date().toISOString()}\n`;
-    reportContent += `**复杂度**: ${complexity}\n\n`;
-    reportContent += `## 子系统覆盖\n\n`;
-    reportContent += `- 总计：${coverageReport.summary.totalSubsystems} 个子系统\n`;
-    reportContent += `- 已完成：${coverageReport.summary.completed}\n`;
-    reportContent += `- 进行中：${coverageReport.summary.inProgress}\n`;
-    reportContent += `- 待开始：${coverageReport.summary.pending}\n`;
-    reportContent += `- 覆盖率：${coverageReport.summary.coverageRate}%\n\n`;
-
-    if (alerts.length > 0) {
-      reportContent += `## 发现的问题\n\n`;
-      for (let i = 0; i < alerts.length; i++) {
-        const alert = alerts[i];
-        reportContent += `### ${i + 1}. [${alert.severity.toUpperCase()}] ${alert.title}\n`;
-        reportContent += `- ${alert.description}\n`;
-        if (alert.suggestion) {
-          reportContent += `- 建议：${alert.suggestion}\n`;
-        }
-        reportContent += '\n';
-      }
-    } else {
-      reportContent += `## 检查结果\n\n✅ 未发现明显问题\n`;
-    }
-
-    fs.writeFileSync(reportPath, reportContent, 'utf-8');
-    logger.info('Monitoring report written', { path: reportPath });
-
-  } catch (e) {
-    logger.error('Failed to execute monitoring check', { error: e.message });
-    alerts.push({
-      severity: 'low',
-      title: '监控检查执行失败',
-      description: `错误信息：${e.message}`,
-      suggestion: '检查日志详情'
-    });
-  }
-
-  return alerts;
-}
-
-/**
- * 输出监控提醒
- */
-function outputMonitoringAlert(projectRoot, alerts) {
-  if (!alerts || alerts.length === 0) {
-    return;
-  }
-
-  const output = {
-    hookSpecificOutput: {
-      hookEventName: 'PostToolUse',
-      additionalContext: buildAlertMessage(alerts)
-    }
-  };
-
-  process.stdout.write(JSON.stringify(output));
-}
-
-/**
- * 构建提醒消息
- */
-function buildAlertMessage(alerts) {
-  let message = '**[AutoSpec 监控提醒]**\n\n';
-
-  for (const alert of alerts) {
-    const icon = alert.severity === 'critical' ? '❗' :
-                 alert.severity === 'high' ? '⚠️' :
-                 alert.severity === 'medium' ? 'ℹ️' : '📝';
-
-    message += `${icon} **${alert.severity.toUpperCase()}** - ${alert.title}\n`;
-    message += `- ${alert.description}\n`;
-    if (alert.suggestion) {
-      message += `- 建议：${alert.suggestion}\n`;
-    }
-    message += '\n';
-  }
-
-  message += '查看详情：`.autospec/monitoring-report.md`\n';
-
-  return message;
-}
-
-async function main() {
-  const startTime = Date.now();
-  let input;
-  let projectRoot = null;
-
-  try {
-    const rawInput = await readStdin(1000);
-    input = safeJsonParse(rawInput, null, 'hook input');
-
-    if (!input) {
-      logger.debug('Empty or invalid input, skipping');
-      process.exit(0);
-    }
-
-    // 只处理 PostToolUse 事件
-    const eventName = input.event_name;
-    if (eventName !== 'PostToolUse') {
-      logger.debug('Not a PostToolUse event, skipping');
-      process.exit(0);
-    }
-
-    // 只处理 Write/Edit 操作
-    const toolName = input.tool_name;
-    if (toolName !== 'Write' && toolName !== 'Edit') {
-      logger.debug('Not a Write/Edit operation, skipping');
-      process.exit(0);
-    }
-
-    // Find project root
-    const cwd = input.cwd || process.cwd();
-    projectRoot = await findProjectRootAsync(cwd);
-
-    if (!projectRoot) {
-      logger.debug('No .autospec directory found, skipping');
-      process.exit(0);
-    }
-
-    // 获取当前状态
-    const state = getState(projectRoot, true);
-    if (!state) {
-      logger.debug('No active pipeline, skipping');
-      process.exit(0);
-    }
-
-    // 获取子系统列表
-    const subsystems = getCurrentStageSubsystems(projectRoot);
-    if (subsystems.length === 0) {
-      // 单系统模式，轻量监控
-      logger.debug('Single-system mode, light monitoring');
-    }
-
-    // 读取变更计数器
-    let counter = readChangeCounter(projectRoot);
-
-    // 检测文件变更属于哪个子系统
-    const filePath = input.tool_input?.file_path || '';
-    if (filePath && !filePath.includes('.autospec')) {
-      const subsystemName = detectSubsystemChange(filePath, subsystems);
-
-      if (subsystemName) {
-        counter.bySubsystem[subsystemName] = (counter.bySubsystem[subsystemName] || 0) + 1;
-        logger.debug(`Subsystem change detected: ${subsystemName}`);
-      }
-
-      counter.total++;
-      counter.lastChangeAt = new Date().toISOString();
-    }
-
-    // 写入变更计数器
-    writeChangeCounter(projectRoot, counter);
-
-    // 检查是否需要触发监控
-    const complexity = getComplexity(state);
-    const lastCheck = readLastCheck(projectRoot);
-
-    if (shouldTriggerMonitoring(counter, lastCheck, complexity)) {
-      const triggered = await triggerMonitoring(projectRoot, complexity);
-
-      if (triggered) {
-        logger.info('Monitoring check triggered', { complexity, changeCount: counter.total });
-
-        // 输出提醒（如果有）
-        // 注意：实际的警报由 monitoring-agent 生成
-        // 这里只输出触发通知
-        const output = {
-          hookSpecificOutput: {
-            hookEventName: 'PostToolUse',
-            additionalContext: `**[AutoSpec 监控]** 已触发后台巡检（复杂度：${complexity}，变更数：${counter.total}）`
-          }
-        };
-        process.stdout.write(JSON.stringify(output));
-      }
-    }
-
-    // 记录成功执行
-    recordHookExecution(projectRoot, 'monitoring-trigger', input, null, startTime - Date.now(), true);
-    process.exit(0);
-
-  } catch (err) {
-    // 使用增强的错误处理
-    const result = handleHookError('monitoring-trigger', err, {
-      eventName: input?.event_name || 'Unknown',
-      projectRoot,
-      input
-    });
-
-    // 记录失败的执行
-    if (projectRoot) {
-      recordHookExecution(projectRoot, 'monitoring-trigger', input, result, Date.now() - startTime, false);
-    }
-
-    process.stdout.write(JSON.stringify(result.hookSpecificOutput));
-    process.exit(0);
-  }
-}
-
-main();