@chongyan/autospec 1.0.1

package/plugins/hooks/execution-tracker.js

@@ -0,0 +1,354 @@
+#!/usr/bin/env node
+
+/**
+ * AutoSpec PostToolUse Hook: Execution Tracker
+ *
+ * Tracks execution of key steps in the AutoSpec pipeline:
+ * - Skill loading
+ * - Agent invocation
+ * - Stage completion
+ * - Artifact generation
+ *
+ * 增强功能：
+ * - Trace ID 支持：所有事件关联到 traceId
+ * - 统一事件格式：标准化的事件结构
+ * - 双写机制：同时写入每日日志和 trace 日志
+ *
+ * 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 } from './lib/hook-state-manager.js';
+import { generateEventId, getTraceId, appendTraceEvent } from './lib/trace-context.js';
+import fs from 'fs';
+import path from 'path';
+
+const logger = createHookLogger('execution-tracker');
+
+// Key artifacts to track
+const ARTIFACT_PATTERNS = {
+  // Requirement stage
+  'requirement.md': { stage: '01-require', type: 'deliverable' },
+  'review-requirement.md': { stage: '01-require', type: 'review' },
+
+  // Design stage
+  'design.md': { stage: '02-design', type: 'deliverable' },
+  'review-design.md': { stage: '02-design', type: 'review' },
+
+  // Implementation stage
+  'review-code.md': { stage: '03-implement', type: 'review' },
+
+  // Testing stage
+  'tests/': { stage: '05-testing', type: 'deliverable' },
+  'review-testing.md': { stage: '05-testing', type: 'review' },
+  'evaluation-report.md': { stage: '05-testing', type: 'evaluation' },
+
+  // Delivery stage
+  'consistency-report.md': { stage: '06-delivery', type: 'report' },
+  'safety-audit-': { stage: '06-delivery', type: 'audit' },
+
+  // Practice log
+  'practice-log/': { stage: 'evolution', type: 'log' }
+};
+
+// Execution log file
+function getLogPath(projectRoot) {
+  const date = new Date().toISOString().split('T')[0];
+  return path.join(projectRoot, '.autospec', 'logs', `execution-${date}.json`);
+}
+
+function ensureLogDir(projectRoot) {
+  const logDir = path.join(projectRoot, '.autospec', 'logs');
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+}
+
+function readLog(projectRoot) {
+  const logPath = getLogPath(projectRoot);
+  if (fs.existsSync(logPath)) {
+    try {
+      return JSON.parse(fs.readFileSync(logPath, 'utf-8'));
+    } catch {
+      return { entries: [], summary: {} };
+    }
+  }
+  return { entries: [], summary: {} };
+}
+
+function writeLog(projectRoot, logData) {
+  const logPath = getLogPath(projectRoot);
+  ensureLogDir(projectRoot);
+  fs.writeFileSync(logPath, JSON.stringify(logData, null, 2), 'utf-8');
+}
+
+/**
+ * 创建标准化事件对象
+ * @param {string} projectRoot - 项目根目录
+ * @param {string} type - 事件类型
+ * @param {Object} data - 事件数据
+ * @returns {Object} 标准化事件对象
+ */
+function createEvent(projectRoot, type, data = {}) {
+  const state = getState(projectRoot);
+  const traceId = getTraceId(projectRoot);
+
+  return {
+    eventId: generateEventId(),
+    traceId,
+    timestamp: new Date().toISOString(),
+    type,
+    source: 'execution-tracker',
+    stage: state?.currentStage || data.stage || null,
+    tool: data.tool || null,
+    action: data.action || null,
+    data: data.data || {},
+    metadata: {
+      projectRoot,
+      executionMode: state?.executionMode || 'interactive'
+    }
+  };
+}
+
+function addEntry(logData, entry, projectRoot = null) {
+  // 创建标准化事件
+  const event = {
+    timestamp: new Date().toISOString(),
+    ...entry
+  };
+
+  // 如果有 projectRoot，添加 Trace ID
+  if (projectRoot) {
+    const traceId = getTraceId(projectRoot);
+    if (traceId) {
+      event.traceId = traceId;
+      event.eventId = generateEventId();
+    }
+  }
+
+  logData.entries.push(event);
+
+  // Update summary
+  const stage = entry.stage || 'unknown';
+  if (!logData.summary[stage]) {
+    logData.summary[stage] = { count: 0, artifacts: [], reviews: [] };
+  }
+  logData.summary[stage].count++;
+
+  if (entry.artifacts) {
+    logData.summary[stage].artifacts.push(...entry.artifacts);
+  }
+  if (entry.reviewed) {
+    logData.summary[stage].reviews.push(entry.reviewed);
+  }
+
+  return event;
+}
+
+function detectArtifactType(filePath) {
+  for (const [pattern, info] of Object.entries(ARTIFACT_PATTERNS)) {
+    if (filePath.includes(pattern)) {
+      return info;
+    }
+  }
+  return null;
+}
+
+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 toolName = input.tool_name;
+
+  // Track Write operations for artifact generation
+  if (toolName === 'Write') {
+    const filePath = input.tool_input?.file_path || '';
+
+    // Find project root
+    const cwd = input.cwd || process.cwd();
+    const projectRoot = await findProjectRootAsync(cwd);
+
+    if (!projectRoot) {
+      logger.debug('No .autospec directory found, skipping');
+      process.exit(0);
+    }
+
+    // Check if this is a key artifact
+    const artifactInfo = detectArtifactType(filePath);
+    if (artifactInfo) {
+      logger.info('Detected key artifact', { filePath, ...artifactInfo });
+
+      // 读取文件内容用于调试和评测
+      let contentPreview = '';
+      let contentLength = 0;
+      try {
+        if (fs.existsSync(filePath)) {
+          const content = fs.readFileSync(filePath, 'utf-8');
+          contentLength = content.length;
+          // 截取前 500 字符作为预览
+          contentPreview = content.length > 500
+            ? content.substring(0, 500) + '... [truncated]'
+            : content;
+        }
+      } catch (e) {
+        // 忽略读取错误
+      }
+
+      const logData = readLog(projectRoot);
+      const event = addEntry(logData, {
+        event: 'artifact_created',
+        file: filePath,
+        stage: artifactInfo.stage,
+        type: artifactInfo.type,
+        // 增强：记录内容预览用于调试
+        contentPreview,
+        contentLength
+      }, projectRoot);
+      writeLog(projectRoot, logData);
+
+      // 同时写入 trace 日志（包含完整内容用于深度分析）
+      const traceEvent = createEvent(projectRoot, 'artifact_created', {
+        stage: artifactInfo.stage,
+        tool: 'Write',
+        action: 'create_artifact',
+        data: {
+          file: filePath,
+          artifactType: artifactInfo.type,
+          // 完整内容用于深度评测（仅关键文件）
+          fullContent: artifactInfo.type === 'deliverable' ? contentPreview : null,
+          contentLength
+        }
+      });
+      appendTraceEvent(projectRoot, traceEvent);
+    }
+  }
+
+  // Track Agent tool usage for review invocations
+  if (toolName === 'Agent') {
+    const subagentType = input.tool_input?.subagent_type || '';
+    const prompt = input.tool_input?.prompt || '';
+
+    const cwd = input.cwd || process.cwd();
+    const projectRoot = await findProjectRootAsync(cwd);
+
+    if (projectRoot && subagentType) {
+      logger.info('Detected Agent invocation', { subagentType });
+
+      const logData = readLog(projectRoot);
+
+      // Determine what type of review this is
+      let reviewType = 'unknown';
+      if (subagentType.includes('reviewer')) {
+        reviewType = 'review';
+      } else if (subagentType.includes('consistency')) {
+        reviewType = 'consistency';
+      } else if (subagentType.includes('safety')) {
+        reviewType = 'safety';
+      } else if (subagentType.includes('diagnose')) {
+        reviewType = 'diagnosis';
+      } else if (subagentType.includes('ceo') || subagentType.includes('challenger')) {
+        reviewType = 'exploration';
+      }
+
+      // 截取 prompt 关键信息用于调试和评测
+      const promptPreview = prompt.length > 500
+        ? prompt.substring(0, 500) + '... [truncated]'
+        : prompt;
+
+      const event = addEntry(logData, {
+        event: 'agent_invoked',
+        subagent: subagentType,
+        reviewType,
+        stage: 'inferred_from_subagent',
+        // 增强：记录 prompt 预览用于调试和评测
+        promptPreview,
+        promptLength: prompt.length
+      }, projectRoot);
+      writeLog(projectRoot, logData);
+
+      // 同时写入 trace 日志（包含完整 prompt 用于深度分析）
+      const traceEvent = createEvent(projectRoot, 'agent_invoked', {
+        tool: 'Agent',
+        action: 'invoke_agent',
+        data: {
+          subagentType,
+          reviewType,
+          // 完整 prompt 用于深度评测
+          fullPrompt: prompt,
+          promptLength: prompt.length
+        }
+      });
+      appendTraceEvent(projectRoot, traceEvent);
+    }
+  }
+
+  // Track Agent response (PostAgentCompletion hook would capture this)
+  // 注意：Agent 的 response 需要通过其他 hook 或日志系统捕获
+  // 这里我们记录 Agent 调用开始，等待 response hook 补充
+
+  // Track stage gate completions by checking state.json
+  if (toolName === 'Write' || toolName === 'Edit') {
+    const filePath = input.tool_input?.file_path || '';
+
+    if (filePath.includes('state.json')) {
+      const cwd = input.cwd || process.cwd();
+      const projectRoot = await findProjectRootAsync(cwd);
+
+      if (projectRoot) {
+        const statePath = path.join(projectRoot, '.autospec', 'runtime', 'state.json');
+        if (fs.existsSync(statePath)) {
+          try {
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            if (state.currentStage) {
+              logger.info('Stage transition detected', { stage: state.currentStage });
+
+              const logData = readLog(projectRoot);
+              const event = addEntry(logData, {
+                event: 'stage_completed',
+                stage: state.currentStage,
+                completedAt: state.completedAt
+              }, projectRoot);
+              writeLog(projectRoot, logData);
+
+              // 同时写入 trace 日志
+              const traceEvent = createEvent(projectRoot, 'stage_completed', {
+                stage: state.currentStage,
+                tool: toolName,
+                action: 'complete_stage',
+                data: {
+                  completedAt: state.completedAt
+                }
+              });
+              appendTraceEvent(projectRoot, traceEvent);
+            }
+          } catch {
+            // Ignore state.json parsing errors
+          }
+        }
+      }
+    }
+  }
+
+  process.exit(0);
+}
+
+main().catch((err) => {
+  const result = handleHookError('execution-tracker', err, {
+    eventName: 'PostToolUse'
+  });
+  process.stdout.write(JSON.stringify(result.hookSpecificOutput));
+  // Low 优先级 hook：fail-open
+  process.exit(0);
+});

package/plugins/hooks/frozen-zone-guard.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+
+/**
+ * AutoSpec PreToolUse Hook: Frozen Zone Guard
+ *
+ * Blocks writes/edits to frozen-zone files (constitution, evolution rules, core principles).
+ * See framework/evolution.md for zone definitions.
+ *
+ * Security Level: CRITICAL - fail-closed
+ */
+
+import { createHookLogger, safeJsonParse, handleHookError, readStdin, findProjectRootAsync, matchesAnyPattern } from './lib/hook-logger.js';
+import { recordHookExecution } from './lib/hook-error-recorder.js';
+
+const logger = createHookLogger('frozen-zone-guard');
+
+const FROZEN_PATTERNS = [
+  /constitution\.md$/,
+  /evolution\.md$/,
+  /design-philosophy\.md$/,     // Core principles (DP1-DP3)
+  /pipeline\/overview\.md$/,    // Startup gate + dual validation definitions
+  // 全局冻结区模式
+  /\.claude\/autospec\/knowledge\/principles\/constitution\.md$/,
+  /\.claude\/autospec\/knowledge\/principles\/evolution\.md$/,
+  /\.claude\/autospec\/knowledge\/principles\/design-philosophy\.md$/,
+  // 组织冻结区模式
+  /\.claude\/autospec\/orgs\/[^\/]+\/knowledge\/principles\//
+];
+
+// 检查是否为全局/组织路径
+function isGlobalOrOrgPath(filePath) {
+  return filePath.includes('/.claude/autospec/') ||
+         filePath.includes('\\.claude\\autospec\\');
+}
+
+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);
+    }
+
+    const toolName = input.tool_name;
+    if (toolName !== 'Write' && toolName !== 'Edit') {
+      logger.debug('Not a write/edit operation, skipping', { toolName });
+      process.exit(0);
+    }
+
+    const filePath = (input.tool_input?.file_path || '').replace(/\\/g, '/');
+    if (!filePath) {
+      logger.debug('No file path in input, skipping');
+      process.exit(0);
+    }
+
+    logger.debug('Checking file', { filePath, toolName });
+
+    // 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);
+    }
+
+    logger.debug('Project root found', { projectRoot });
+
+    // Check if file is in framework directory or global/org directory
+    const inFramework = filePath.includes('.autospec/knowledge/') ||
+                       filePath.includes('/knowledge/');
+    const inGlobalOrOrg = isGlobalOrOrgPath(filePath);
+
+    if (!inFramework && !inGlobalOrOrg) {
+      logger.debug('File not in framework or global/org directory, allowing', { filePath });
+      // 记录成功执行
+      recordHookExecution(projectRoot, 'frozen-zone-guard', input, null, Date.now() - startTime, true);
+      process.exit(0);
+    }
+
+    logger.debug('File in framework or global/org, checking frozen patterns', { filePath });
+
+    // Check against frozen patterns (for both framework and global/org paths)
+    if (matchesAnyPattern(filePath, FROZEN_PATTERNS)) {
+      logger.info('Blocked write to frozen zone', { filePath });
+
+      const output = {
+        hookSpecificOutput: {
+          hookEventName: 'PreToolUse',
+          permissionDecision: 'deny',
+          permissionDecisionReason:
+            `FROZEN ZONE: ${filePath} is protected by AutoSpec evolution rules. ` +
+            `This file can only be modified through a human-initiated change process. ` +
+            `See framework/evolution.md for details.`
+        }
+      };
+
+      // 记录成功执行（阻止操作是预期行为）
+      recordHookExecution(projectRoot, 'frozen-zone-guard', input, output, Date.now() - startTime, true);
+      process.stdout.write(JSON.stringify(output));
+      process.exit(0);
+    }
+
+    logger.debug('File not in frozen zone, allowing', { filePath });
+    // 记录成功执行
+    recordHookExecution(projectRoot, 'frozen-zone-guard', input, null, Date.now() - startTime, true);
+    process.exit(0);
+
+  } catch (err) {
+    // 使用增强的错误处理
+    const result = handleHookError('frozen-zone-guard', err, {
+      eventName: 'PreToolUse',
+      projectRoot,
+      input
+    });
+
+    // 记录失败的执行
+    if (projectRoot) {
+      recordHookExecution(projectRoot, 'frozen-zone-guard', input, result, Date.now() - startTime, false);
+    }
+
+    process.stdout.write(JSON.stringify(result.hookSpecificOutput));
+
+    // 关键 hook：根据错误类型决定退出码
+    // fail-closed: 如果 shouldBlock 为 true，使用 exit(2) 阻止操作
+    if (result.shouldBlock) {
+      process.exit(2);
+    } else {
+      process.exit(0);
+    }
+  }
+}
+
+main();