@chongyan/autospec 1.0.1 → 1.0.2

package/plugins/hooks/monitoring-trigger.js

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

package/plugins/skills/README.en.md

@@ -20,8 +20,20 @@ skills/
 │   └── SKILL.md                   # QA testing stage
 ├── delivery-stage/
 │   └── SKILL.md                   # Delivery and deployment stage
-├── evolution-process/
-│   └── SKILL.md                   # Self-evolution (auto-triggered)
+├── field-evolve-scanner/          # L2 Field evolution - Scanner
+├── field-evolve-executor/         # L2 Field evolution - Executor
+├── field-evolve-analyzer/         # L2 Field evolution - Analyzer
+├── field-evolve-fixer/            # L2 Field evolution - Fixer
+├── field-evolve-verifier/         # L2 Field evolution - Verifier
+├── field-evolve-learner/          # L2 Field evolution - Learner
+├── field-evolve-distiller/        # L2 Field evolution - Distiller
+├── project-evolve-scanner/        # L3 Project evolution - Scanner
+├── project-evolve-analyzer/       # L3 Project evolution - Analyzer
+├── project-evolve-fixer/          # L3 Project evolution - Fixer
+├── project-evolve-verifier/       # L3 Project evolution - Verifier
+├── project-evolve-reviewer/       # L3 Project evolution - Reviewer
+├── project-evolve-learner/        # L3 Project evolution - Learner
+├── project-evolve-generator/      # L3 Project evolution - Generator
 ├── pending-dashboard/
 │   └── SKILL.md                   # Pending dashboard (session startup trigger)
 └── README.md                      # This file
@@ -32,7 +44,7 @@ skills/
 **Auto-triggered**:
 - `startup-guard`: Auto-triggered when development task detected
 - `layer1-validation`: Auto-triggered after code changes
-- `evolution-process`: Auto-triggered after pipeline completion
+- `field-evolve-*`: Auto-triggered after pipeline completion (L2 Field-Evolve)
 - `pending-dashboard`: Auto-triggered on session startup
 
 **Stage-based**:

package/plugins/skills/README.md

@@ -7,7 +7,7 @@
 ```
 ┌─────────────────────────────────────────────────────────────────┐
 │  人类维护层 (Human-maintained)                                    │
-│  ../knowledge/domain/ - 业务知识（术语、规则、流程）                │
+│  ../knowledge/03-guides/domain-*.md - 业务知识（术语、规则）          │
 │  由领域专家维护，AI 读取但不修改                                   │
 └─────────────────────────────────────────────────────────────────┘
                               ↓ 驱动
@@ -48,10 +48,20 @@ skills/
 │   └── SKILL.md                   # QA测试阶段（含 Benchmarks 评测）
 ├── delivery-stage/
 │   └── SKILL.md                   # 交付部署阶段
-├── evolution-process/
-│   └── SKILL.md                   # 自进化（自动触发）- L2 Field-Evolve
-├── project-evolution/
-│   └── SKILL.md                   # 项目进化 - L3 Project-Evolve
+├── field-evolve-scanner/          # L2 领域进化 - 扫描
+├── field-evolve-executor/         # L2 领域进化 - 执行
+├── field-evolve-analyzer/         # L2 领域进化 - 分析
+├── field-evolve-fixer/            # L2 领域进化 - 修复
+├── field-evolve-verifier/         # L2 领域进化 - 验证
+├── field-evolve-learner/          # L2 领域进化 - 学习
+├── field-evolve-distiller/        # L2 领域进化 - 蒸馏
+├── project-evolve-scanner/        # L3 项目进化 - 扫描
+├── project-evolve-analyzer/       # L3 项目进化 - 分析
+├── project-evolve-fixer/          # L3 项目进化 - 修复
+├── project-evolve-verifier/       # L3 项目进化 - 验证
+├── project-evolve-reviewer/       # L3 项目进化 - 审查
+├── project-evolve-learner/        # L3 项目进化 - 学习
+├── project-evolve-generator/      # L3 项目进化 - 生成
 ├── benchmark-generator/
 │   ├── SKILL.md                   # Benchmarks 自动生成
 │   └── README.md                  # 使用文档
@@ -73,7 +83,7 @@ skills/
 **自动触发型**：
 - `startup-guard`：检测到开发任务时自动触发
 - `layer1-validation`：代码变更后自动触发
-- `evolution-process`：流程完成后自动触发（L2 Field-Evolve）
+- `field-evolve-*`：流程完成后自动触发（L2 Field-Evolve）
 - `pending-dashboard`：会话启动时自动触发
 
 **阶段流程型**：
@@ -89,15 +99,15 @@ skills/
 
 **进化支撑型**：
 - `skill-forge`：技能锻造系统（蒸馏新建/迭代进化/Description优化）
-- `project-evolution`：项目自我进化（L3 Project-Evolve）
+- `project-evolve-*`：项目自我进化技能组（L3 Project-Evolve）
 
 ### 按三层自进化体系分类
 
-| 层级 | 命令 | Skill |
-|------|------|-------|
+| 层级 | 命令 | Skill 组合 |
+|------|------|-----------|
 | L1: Self-Evolve | `/self-evolve` | `self-evolve/*`（位于 `.claude/skills/`） |
-| L2: Field-Evolve | `/autospec:field-evolve` | `evolution-process` |
-| L3: Project-Evolve | `/autospec:project-evolve` | `project-evolution` |
+| L2: Field-Evolve | `/autospec:field-evolve` | `field-evolve-{scanner,executor,analyzer,fixer,verifier,learner,distiller}` |
+| L3: Project-Evolve | `/autospec:project-evolve` | `project-evolve-{scanner,analyzer,fixer,verifier,reviewer,learner,generator}` |
 
 ## 变量替换