@winspan/claude-forge 4.1.0 → 6.1.0

package/dist/autopilot/quality-gate.js

@@ -1,815 +0,0 @@
-import { logger } from '../utils/logger.js';
-import { PromptRegistry } from '../prompts/registry.js';
-import { cacheRegistry } from '../utils/cache-registry.js';
-import { PHASE_LABELS } from '../types/core-types.js';
-import { IssueTracker } from './issue-tracker.js';
-import { PhaseGapDetector } from './phase-gap-detector.js';
-import { isNonCodeFile, isLowRiskFile, mapCheckToCategory } from './quality-gate-utils.js';
-import { createHash } from 'crypto';
-import fs from 'fs';
-import { QUALITY_GATE, TIME, CONTENT_LIMIT, CACHE, TRUNCATION } from '../constants.js';
-/**
- * QualityGateEngine — AI 驱动的质量门禁
- *
- * 在 PostToolUse 阶段对代码变更进行审查：
- * - spec: 是否符合需求规格
- * - security: 安全性检查
- * - quality: 代码质量
- * - test: 测试覆盖
- * - performance: 性能问题
- *
- * 审查策略根据用户反馈自进化：
- * - 用户接受的审查意见 → 强化该规则
- * - 用户忽略的审查意见 → 弱化该规则
- */
-export class QualityGateEngine {
-    api;
-    storage = null; // v5 新增：持久化支持
-    currentProjectPath = ''; // v5 新增：当前项目路径
-    currentSessionId = ''; // v5 新增：当前会话 ID
-    sessionHistoryRestored = false; // 标记当前会话历史是否已恢复，避免重复恢复
-    currentRequirement = '';
-    currentPipelineId = ''; // 当前 Pipeline ID，供 IssueTracker 使用
-    currentTaskType = 'other';
-    reviewHistory = [];
-    checkCount = 0;
-    static REVIEW_INTERVAL = QUALITY_GATE.REVIEW_INTERVAL; // 每 N 次 Write/Edit 触发 1 次审查
-    skipPatterns = cacheRegistry.register('quality:skipPatterns', { max: 20, ttl: TIME.WEEK }); // 7天 TTL，Map 模拟 Set
-    conventionStandards = []; // 当前项目绑定的 Convention 质量规范
-    static MAX_HISTORY_LENGTH = 50; // 限制历史记录长度，避免内存泄漏
-    /** AI 审查结果缓存：filePath:contentHash → QualityResult（TTL 1h） */
-    reviewCache = cacheRegistry.register('quality:reviewCache', { max: CACHE.QUALITY_REVIEW_MAX, ttl: TIME.HOUR });
-    /** 问题台账：跨阶段追踪所有发现的问题 */
-    issueTracker = new IssueTracker();
-    /** 跨阶段补充触发器：供 执行器 在阶段推进时调用 */
-    phaseGapDetector = new PhaseGapDetector(this.issueTracker);
-    constructor(api, storage) {
-        this.api = api;
-        if (storage) {
-            this.storage = storage;
-        }
-    }
-    /**
-     * v5 新增：设置当前会话上下文（用于持久化）
-     * P1-2 补完：同时恢复 reviewHistory，使跨轮次的忽略计数正确累积
-     * 优化：检测会话切换，避免同一会话重复恢复历史
-     *
-     * @param sessionId - 会话 ID
-     * @param projectPath - 项目根目录路径
-     */
-    setSessionContext(sessionId, projectPath) {
-        // 检测会话是否切换
-        const sessionChanged = this.currentSessionId !== sessionId;
-        this.currentSessionId = sessionId;
-        this.currentProjectPath = projectPath;
-        if (this.storage && projectPath) {
-            // 从数据库加载未过期的抑制规则（每次都加载，因为可能在运行时更新）
-            this.loadSuppressions(projectPath);
-            // 只在会话切换时恢复历史，避免重复恢复
-            if (sessionChanged && !this.sessionHistoryRestored) {
-                this.restoreSessionHistory(sessionId, projectPath);
-                this.sessionHistoryRestored = true;
-            }
-        }
-    }
-    /**
-     * v5 新增：从数据库加载未过期的抑制规则
-     */
-    loadSuppressions(projectPath) {
-        if (!this.storage)
-            return;
-        try {
-            const categories = this.storage.getActiveSuppressions(projectPath);
-            categories.forEach(c => this.skipPatterns.set(c, true));
-            if (categories.length > 0) {
-                logger.info(`[Forge:质量检查] 跳过 ${categories.length} 类检查：${categories.join(', ')}（用户已标记为"不再检查"）`);
-            }
-        }
-        catch (err) {
-            logger.warn(`[Forge:质量检查] 加载跳过规则失败：${err}`);
-        }
-    }
-    /**
-     * P1-2 新增：从数据库恢复本次会话的审查历史
-     * 使 feedback() 的忽略计数在重启后仍能正确累积，最终触发自动抑制
-     */
-    restoreSessionHistory(sessionId, projectPath) {
-        if (!this.storage)
-            return;
-        try {
-            const rows = this.storage.getSessionQualityHistory(sessionId, projectPath);
-            if (rows.length === 0)
-                return;
-            // 按文件路径分组，重建 reviewHistory 结构
-            // 同一文件的所有 check 聚合为一条 QualityResult
-            const fileMap = new Map();
-            for (const row of rows) {
-                const entry = fileMap.get(row.file_path) ?? { checks: [], resolved: false };
-                entry.checks.push({
-                    category: row.category,
-                    level: row.level,
-                    message: row.message,
-                });
-                if (row.resolved)
-                    entry.resolved = true;
-                fileMap.set(row.file_path, entry);
-            }
-            for (const [filePath, { checks, resolved }] of fileMap) {
-                const level = checks.some(c => c.level === 'fail') ? 'fail'
-                    : checks.some(c => c.level === 'warn') ? 'warn' : 'pass';
-                this.reviewHistory.push({
-                    result: { level, checks, summary: `[已恢复] ${filePath}` },
-                    accepted: level === 'pass',
-                    filePath,
-                    resolved,
-                });
-            }
-            logger.info(`[Forge:质量检查] 恢复了 ${fileMap.size} 个文件的检查记录（跨会话保留）`);
-        }
-        catch (err) {
-            logger.warn(`[Forge:质量检查] 恢复检查记录失败：${err}`);
-        }
-    }
-    /**
-     * 设置当前需求（从 Pipeline 获取）
-     *
-     * @param requirement - 用户需求描述
-     */
-    setRequirement(requirement) {
-        this.currentRequirement = requirement;
-    }
-    /**
-     * 设置当前任务类型（影响质量检查策略）
-     *
-     * @param taskType - 任务类型（如 'feature', 'bugfix', 'refactor' 等）
-     */
-    setTaskType(taskType) {
-        this.currentTaskType = taskType;
-    }
-    /**
-     * 设置当前 Pipeline ID（供 IssueTracker 使用）
-     *
-     * @param pipelineId - Pipeline 唯一标识符
-     */
-    setPipelineId(pipelineId) {
-        this.currentPipelineId = pipelineId;
-    }
-    /**
-     * 返回问题台账（供 PipelineReportGenerator 使用）
-     *
-     * @returns IssueTracker 实例
-     */
-    getIssueTracker() {
-        return this.issueTracker;
-    }
-    /**
-     * 设置当前项目绑定的 Convention 质量规范
-     * must 级别规范将在 reviewForPhase 中作为强制检查维度注入
-     *
-     * @param standards - 质量规范数组
-     */
-    setConventionStandards(standards) {
-        this.conventionStandards = standards;
-    }
-    /**
-     * 审查代码变更
-     * 只对 Write/Edit 操作触发，且有节流控制（每 N 次触发 1 次）
-     *
-     * @param event - Forge 事件对象，包含工具名称、文件路径、内容等
-     * @returns 审查结果对象，不满足触发条件时返回 null
-     */
-    async review(event) {
-        const toolName = event.tool_name || '';
-        // 只审查写入操作
-        if (toolName !== 'Write' && toolName !== 'Edit')
-            return null;
-        // 节流：每 REVIEW_INTERVAL 次 Write/Edit 才触发 1 次审查
-        this.checkCount++;
-        if (this.checkCount % QualityGateEngine.REVIEW_INTERVAL !== 0)
-            return null;
-        const input = event.tool_input || {};
-        const filePath = input.file_path || '';
-        let content = input.content ||
-            input.new_string || '';
-        // 跳过非代码文件
-        if (isNonCodeFile(filePath))
-            return null;
-        // 跳过低风险文件：测试文件、配置文件无需质量审查
-        if (isLowRiskFile(filePath))
-            return null;
-        // Edit 操作：提取 diff 用于增量审查，同时读取完整文件作为回退
-        let diff;
-        if (toolName === 'Edit' && filePath) {
-            const oldStr = input.old_string || '';
-            const newStr = input.new_string || '';
-            if (oldStr && newStr) {
-                diff = { oldStr, newStr };
-            }
-            // 读取完整文件作为回退（增量审查失败时使用）
-            try {
-                const fullContent = fs.readFileSync(filePath, 'utf-8');
-                if (fullContent.length > 0)
-                    content = fullContent;
-            }
-            catch { /* 读取失败时回退到 new_string */ }
-        }
-        // 跳过太短的变更
-        if (content.length < 50 && (!diff || (diff.oldStr.length + diff.newStr.length) < 50))
-            return null;
-        try {
-            return await this.aiReview(filePath, content, toolName, diff);
-        }
-        catch (err) {
-            logger.warn(`[Forge:质量检查] 检查出错：${err}`);
-            return null;
-        }
-    }
-    /**
-     * v5 新增：检测用户是否修复了历史问题
-     * v6 增强：支持部分修复检测（不仅仅是全文件通过）
-     */
-    markHistoricalIssuesResolved(filePath, result) {
-        if (!this.storage)
-            return;
-        try {
-            // 查询该文件的未解决问题
-            const unresolvedIssues = this.storage.getUnresolvedIssues(filePath);
-            if (unresolvedIssues.length === 0)
-                return;
-            // 收集本次检查中出现的问题消息
-            const currentMessages = new Set(result.checks.map(c => c.message));
-            // 标记不再出现的问题为已解决（按消息内容匹配）
-            let resolvedCount = 0;
-            for (const issue of unresolvedIssues) {
-                if (!currentMessages.has(issue.message)) {
-                    this.storage.markQualityIssueResolvedByMessage(filePath, issue.message);
-                    resolvedCount++;
-                }
-            }
-            // 更新内存中的 reviewHistory
-            if (resolvedCount > 0) {
-                for (const h of this.reviewHistory) {
-                    if (h.filePath === filePath && !currentMessages.has(h.result.summary)) {
-                        h.resolved = true;
-                    }
-                }
-                logger.info(`[Forge:质量检查] ${filePath} 自动解决了 ${resolvedCount} 个历史问题`);
-            }
-        }
-        catch (err) {
-            logger.warn(`[Forge:质量检查] 标记问题修复失败：${err}`);
-        }
-    }
-    /**
-     * AI 驱动的代码审查
-     * @param diff Edit 操作的变更摘要（old_string → new_string），有则优先用于增量审查
-     */
-    async aiReview(filePath, content, operation, diff) {
-        // 增量审查：Edit 操作优先只审查 diff 部分，大幅缩短 prompt
-        // 当 diff 较小时使用增量模式，否则回退到全文审查
-        const useIncrementalReview = diff && (diff.oldStr.length + diff.newStr.length) < CONTENT_LIMIT.INCREMENTAL_REVIEW_DIFF;
-        const reviewContent = useIncrementalReview
-            ? `[增量审查] 只审查本次变更部分：\n旧：\n${diff.oldStr}\n新：\n${diff.newStr}`
-            : content;
-        // 缓存键：filePath + content hash（增量模式用 diff hash）
-        const hashInput = useIncrementalReview ? `${diff.oldStr}:${diff.newStr}` : content;
-        const contentHash = createHash('sha256').update(hashInput).digest('hex').slice(0, 16);
-        const cacheKey = `${filePath}:${contentHash}`;
-        const cached = this.reviewCache.get(cacheKey);
-        if (cached) {
-            logger.debug(`[质量门禁] 命中缓存：${filePath}`);
-            return cached;
-        }
-        // 构建审查上下文
-        const suppressedCategories = Array.from(this.skipPatterns.keys());
-        const requirementSection = this.currentRequirement ? `## 需求规格\n${this.currentRequirement}` : '';
-        const suppressedSection = suppressedCategories.length > 0 ? `## 已抑制的检查类别（不要重复提）\n${suppressedCategories.join(', ')}` : '';
-        // 截断：增量模式已经很短，全文模式限制字符
-        const truncatedContent = useIncrementalReview
-            ? reviewContent
-            : (reviewContent.length > TRUNCATION.QUALITY_GATE_CONTENT ? reviewContent.substring(0, TRUNCATION.QUALITY_GATE_CONTENT) + '\n... (内容已截断)' : reviewContent);
-        const prompt = PromptRegistry.load('quality-review', {
-            operation: useIncrementalReview ? `${operation}(增量)` : operation,
-            filePath,
-            content: truncatedContent,
-            requirementSection,
-            suppressedSection,
-        });
-        logger.debug(`[质量门禁] 正在审查 ${filePath}${useIncrementalReview ? '（增量模式）' : ''}…`);
-        const response = await this.api.complete(prompt, 'quality-gate');
-        let result;
-        try {
-            result = this.parseResult(response, filePath);
-        }
-        catch (err) {
-            // AI 响应解析失败，跳过本次检查，不计入统计
-            logger.warn(`[Forge:质量检查] ${filePath} 解析失败，跳过本次检查`);
-            return null;
-        }
-        // 缓存结果
-        this.reviewCache.set(cacheKey, result);
-        // v5 新增：检测历史问题是否已修复
-        this.markHistoricalIssuesResolved(filePath, result);
-        // v5 新增：记录到数据库
-        if (this.storage && this.currentSessionId && this.currentProjectPath) {
-            for (const check of result.checks) {
-                if (check.level !== 'pass') {
-                    const id = `qgh_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
-                    this.storage.insertQualityGateHistory({
-                        id,
-                        session_id: this.currentSessionId,
-                        project_path: this.currentProjectPath,
-                        file_path: filePath,
-                        category: check.category,
-                        level: check.level,
-                        message: check.message,
-                        pipeline_id: this.currentPipelineId || undefined,
-                    });
-                }
-            }
-        }
-        // 问题台账：追踪 fail/warn 问题，并处理修复循环
-        if (this.currentPipelineId && result.level !== 'pass') {
-            // 尝试将已有 open 问题标记为 resolved（同文件 pass 时）
-            // 此处 result.level !== 'pass'，所以只处理新问题
-            for (const check of result.checks.filter(c => c.level !== 'pass')) {
-                const category = mapCheckToCategory(check.category, 'code');
-                const existing = this.issueTracker.getOpenByPhase(this.currentPipelineId, 'code')
-                    .find(i => i.filePath === filePath && i.category === category && i.message === check.message);
-                if (existing) {
-                    // 已有相同问题，增加修复尝试次数并处理修复循环
-                    const attempts = this.issueTracker.incrementFixAttempts(existing.id);
-                    const fixDirective = this.handleFailIssue(existing.id, attempts, result, filePath);
-                    if (fixDirective && result.directive) {
-                        result.directive = fixDirective + '\n\n' + result.directive;
-                    }
-                    else if (fixDirective) {
-                        result.directive = fixDirective;
-                    }
-                }
-                else {
-                    // 新问题，加入台账
-                    this.issueTracker.add(this.currentPipelineId, 'code', category, check.level, check.message, check.suggestion, filePath);
-                }
-            }
-        }
-        return result;
-    }
-    /**
-     * 根据审查结果生成注入指令
-     */
-    generateDirective(result, filePath) {
-        if (result.level === 'pass')
-            return null;
-        const parts = [];
-        const mustFix = result.checks.filter(c => c.level === 'fail');
-        const shouldFix = result.checks.filter(c => c.level === 'warn');
-        // 标题：区分必须修复和建议修复
-        if (mustFix.length > 0) {
-            parts.push(`[Forge QualityGate] ❌ 必须修复（${mustFix.length}个）/ 建议修复（${shouldFix.length}个）`);
-        }
-        else {
-            parts.push(`[Forge QualityGate] ⚠️ 建议修复（${shouldFix.length}个）`);
-        }
-        parts.push(`文件: ${filePath}`);
-        parts.push('');
-        // 必须修复：红色标记，带编号和快速修复建议
-        if (mustFix.length > 0) {
-            parts.push('🔴 立即修复：');
-            mustFix.forEach((check, idx) => {
-                parts.push(`  ${idx + 1}. [${check.category}] ${check.message}`);
-                if (check.suggestion) {
-                    // 将建议拆分为步骤（如果包含换行或编号）
-                    const suggestionLines = check.suggestion.split('\n').filter(l => l.trim());
-                    if (suggestionLines.length > 1) {
-                        parts.push(`     💡 修复步骤：`);
-                        suggestionLines.forEach(line => parts.push(`        ${line.trim()}`));
-                    }
-                    else {
-                        parts.push(`     💡 ${check.suggestion}`);
-                    }
-                }
-            });
-        }
-        // 建议修复：黄色标记，不阻断
-        if (shouldFix.length > 0) {
-            if (mustFix.length > 0)
-                parts.push('');
-            parts.push('🟡 建议修复（不阻断）：');
-            shouldFix.forEach((check, idx) => {
-                parts.push(`  ${idx + 1}. [${check.category}] ${check.message}`);
-            });
-        }
-        if (result.level === 'fail') {
-            parts.push('');
-            parts.push('请立即修复以上 🔴 标记的问题再继续。');
-        }
-        return parts.join('\n');
-    }
-    /**
-     * 反馈：用户是否接受了审查意见
-     */
-    feedback(accepted, categories) {
-        if (!accepted && categories) {
-            // v5 修改：持久化抑制计数
-            for (const cat of categories) {
-                if (this.storage && this.currentProjectPath) {
-                    this.storage.incrementSuppressionCount(cat, this.currentProjectPath);
-                }
-                // 连续 N 次忽略同一类别，自动抑制（配置天数后恢复）
-                const ignoreCount = this.reviewHistory
-                    .filter(h => !h.accepted && h.result.checks.some(c => c.category === cat))
-                    .length;
-                if (ignoreCount >= QUALITY_GATE.SUPPRESSION_THRESHOLD) {
-                    this.skipPatterns.set(cat, true);
-                    logger.info(`[Forge:质量检查] 不再检查 ${cat} 类问题（已忽略 ${ignoreCount} 次，${QUALITY_GATE.SUPPRESSION_EXPIRE_DAYS} 天后自动恢复）`);
-                }
-            }
-        }
-    }
-    /**
-     * 生成阶段性质量报告
-     */
-    generateReport() {
-        if (this.reviewHistory.length === 0)
-            return '暂无审查记录。';
-        // 统一按检查项级别统计（而非文件级别），与分类统计保持一致
-        let totalChecks = 0;
-        let passedChecks = 0;
-        let warnedChecks = 0;
-        let failedChecks = 0;
-        const categoryStats = {};
-        for (const h of this.reviewHistory) {
-            for (const check of h.result.checks) {
-                totalChecks++;
-                if (check.level === 'pass')
-                    passedChecks++;
-                else if (check.level === 'warn')
-                    warnedChecks++;
-                else if (check.level === 'fail')
-                    failedChecks++;
-                if (!categoryStats[check.category]) {
-                    categoryStats[check.category] = { total: 0, issues: 0 };
-                }
-                categoryStats[check.category].total++;
-                if (check.level !== 'pass')
-                    categoryStats[check.category].issues++;
-            }
-        }
-        const lines = [
-            '## Forge 质量报告',
-            '',
-            `检查项: ${totalChecks} | 通过: ${passedChecks} | 警告: ${warnedChecks} | 失败: ${failedChecks}`,
-            `通过率: ${totalChecks > 0 ? ((passedChecks / totalChecks) * 100).toFixed(0) : 0}%`,
-            '',
-            '### 按类别统计',
-        ];
-        for (const [cat, stats] of Object.entries(categoryStats)) {
-            const rate = ((1 - stats.issues / stats.total) * 100).toFixed(0);
-            lines.push(`- ${cat}: ${rate}% 通过 (${stats.issues}/${stats.total} 有问题)`);
-        }
-        if (this.skipPatterns.size > 0) {
-            lines.push('');
-            lines.push(`已自动抑制: ${Array.from(this.skipPatterns.keys()).join(', ')}`);
-        }
-        return lines.join('\n');
-    }
-    /**
-     * 返回本次会话中未解决的 fail 级别问题列表
-     * resolved=true 的条目（后续审查通过的文件）不计入
-     */
-    getUnresolvedFailures() {
-        return this.reviewHistory
-            .filter(h => h.result.level === 'fail' && !h.resolved)
-            .map(h => ({ summary: h.result.summary, checks: h.result.checks.filter(c => c.level === 'fail') }));
-    }
-    /**
-     * 返回本次会话质量门禁通过次数（pass + warn）
-     * 必须在 reset() 之前调用
-     */
-    getPassCount() {
-        return this.reviewHistory.filter(h => h.result.level === 'pass' || h.result.level === 'warn').length;
-    }
-    /**
-     * 返回本次会话质量门禁失败次数
-     * 必须在 reset() 之前调用
-     */
-    getFailCount() {
-        return this.reviewHistory.filter(h => h.result.level === 'fail').length;
-    }
-    /**
-     * 重置（新 Pipeline 开始时）
-     */
-    reset() {
-        if (this.currentPipelineId) {
-            this.issueTracker.resetForPipeline(this.currentPipelineId);
-        }
-        this.currentRequirement = '';
-        this.currentPipelineId = '';
-        this.currentTaskType = 'other';
-        this.reviewHistory = [];
-        this.checkCount = 0;
-        this.sessionHistoryRestored = false; // 重置恢复标志，允许新会话恢复历史
-        // skipPatterns 保留（跨 Pipeline 学习）
-    }
-    /**
-     * 基于阶段描述的质量门禁（无需 Write/Edit 事件，适用于 analyze/design 等文本输出阶段）
-     * 返回 null 表示无需拦截（AI 调用失败时 fail-safe 放行）
-     */
-    async reviewPhaseCompletion(phase, requirement, phaseContext) {
-        const mandatoryCategories = this.getMandatoryCategoriesForPhase(phase);
-        if (mandatoryCategories.length === 0)
-            return null;
-        const mustRules = this.conventionStandards.filter(s => s.severity === 'must' &&
-            (!s.phases || s.phases.length === 0 || s.phases.includes(phase)));
-        const mandatoryNote = `## 本阶段（${phase}）必须通过的检查维度\n${mandatoryCategories.join(', ')}`;
-        const taskTypeNote = this.currentTaskType === 'documentation'
-            ? `\n## 任务类型：文档类任务\n- 重点检查文档完整性、结构清晰度、是否覆盖需求\n- 不要求代码实现、测试覆盖、安全检查\n- 如果文档已生成且内容合理，应判定为 pass`
-            : '';
-        const conventionNote = mustRules.length > 0
-            ? `\n## 项目规范强制要求（must 级别，违反即 fail）\n${mustRules.map(r => {
-                const source = r.conventionName ? ` [来源: ${r.conventionName}]` : '';
-                return `- [${r.category}] ${r.rule}${source}`;
-            }).join('\n')}`
-            : '';
-        const prompt = PromptRegistry.load('quality-phase-completion', {
-            requirement,
-            phase,
-            phaseContext,
-            mandatoryNote,
-            taskTypeNote,
-            conventionNote,
-        });
-        // 最多重试 2 次（首次 + 1 次重试）
-        for (let attempt = 1; attempt <= 2; attempt++) {
-            try {
-                const response = await this.api.complete(prompt, 'quality-gate-phase-completion');
-                const result = this.parseResult(response, `[${phase}阶段]`);
-                logger.info(`[Forge:质量检查] ${PHASE_LABELS[phase]}阶段检查完成：${result.level} — ${result.summary}`);
-                // 问题台账：追踪 fail/warn 问题
-                if (this.currentPipelineId && result.level !== 'pass') {
-                    for (const check of result.checks.filter(c => c.level !== 'pass')) {
-                        const category = mapCheckToCategory(check.category, phase);
-                        this.issueTracker.add(this.currentPipelineId, phase, category, check.level, check.message, check.suggestion);
-                    }
-                }
-                return result;
-            }
-            catch (err) {
-                if (attempt < 2) {
-                    logger.warn(`[质量门禁] 阶段完成度检查失败（第 ${attempt} 次），重试中：${err}`);
-                    await new Promise(r => setTimeout(r, TIME.THREE_SECONDS));
-                }
-                else {
-                    // 两次均失败：返回 null 放行（fail-safe），避免 AI 故障导致 Pipeline 永久阻断
-                    logger.warn(`[质量门禁] 阶段完成度检查连续失败，降级放行：${err}`);
-                    return null;
-                }
-            }
-        }
-        // TypeScript 要求：实际不可达，但需要返回值
-        return null;
-    }
-    /**
-     * 阶段完成时的质量门禁检查（每阶段触发一次，非每次 Write/Edit）
-     * 返回 null 表示不适用（工具类型不匹配、非代码文件等）；失败时返回 warn 而非静默放行
-     */
-    async reviewForPhase(event, phase) {
-        const toolName = event.tool_name || '';
-        if (toolName !== 'Write' && toolName !== 'Edit')
-            return null;
-        const input = event.tool_input || {};
-        const filePath = input.file_path || '';
-        let content = input.content ||
-            input.new_string || '';
-        // Edit 操作：从磁盘读取完整文件内容（PostToolUse 时文件已更新）
-        // 避免 AI 只看到 new_string 片段而误判"未找到实现代码"
-        if (toolName === 'Edit' && filePath) {
-            try {
-                const fullContent = fs.readFileSync(filePath, 'utf-8');
-                if (fullContent.length > 0)
-                    content = fullContent;
-            }
-            catch { /* 读取失败时回退到 new_string */ }
-        }
-        if (isNonCodeFile(filePath))
-            return null;
-        if (content.length < 50)
-            return null;
-        const mandatoryCategories = this.getMandatoryCategoriesForPhase(phase);
-        // 启动日志：显示检查项目
-        const checkItems = mandatoryCategories.length > 0
-            ? mandatoryCategories.join('、')
-            : '规范符合性、安全性、代码质量';
-        logger.info(`[Forge:质量检查] 正在检查 ${filePath}\n  检查项：${checkItems}`);
-        // Convention must-severity 规范：作为额外强制检查条目注入
-        const mustRules = this.conventionStandards.filter(s => s.severity === 'must' &&
-            (!s.phases || s.phases.length === 0 || s.phases.includes(phase)));
-        const suppressedCategories = Array.from(this.skipPatterns.keys());
-        const mandatoryNote = mandatoryCategories.length > 0
-            ? `\n## 本阶段（${phase}）必须通过的检查维度\n${mandatoryCategories.join(', ')}`
-            : '';
-        const conventionNote = mustRules.length > 0
-            ? `\n## 项目规范强制要求（must 级别，违反即 fail）\n${mustRules.map(r => {
-                const source = r.conventionName ? ` [来源: ${r.conventionName}]` : '';
-                return `- [${r.category}] ${r.rule}${source}`;
-            }).join('\n')}`
-            : '';
-        const requirementSection = this.currentRequirement ? `## 需求规格\n${this.currentRequirement}` : '';
-        const suppressedSection = suppressedCategories.length > 0 ? `## 已抑制的检查类别\n${suppressedCategories.join(', ')}` : '';
-        // 任务类型注释：文档/UI 类任务豁免测试覆盖和安全检查
-        const taskTypeNote = (this.currentTaskType === 'documentation')
-            ? `\n## 任务类型：文档类任务\n- 重点检查文档完整性、结构清晰度、是否覆盖需求\n- 不要求代码实现、测试覆盖、安全检查\n- 如果文档已生成且内容合理，应判定为 pass`
-            : '';
-        // Edit 操作：附加 diff 摘要，帮助 AI 理解本次变更的具体内容
-        let diffContext = '';
-        if (toolName === 'Edit') {
-            const oldStr = input.old_string || '';
-            const newStr = input.new_string || '';
-            if (oldStr && newStr) {
-                const oldPreview = oldStr.length > TRUNCATION.QUALITY_GATE_PREVIEW ? oldStr.substring(0, TRUNCATION.QUALITY_GATE_PREVIEW) + '…' : oldStr;
-                const newPreview = newStr.length > TRUNCATION.QUALITY_GATE_PREVIEW ? newStr.substring(0, TRUNCATION.QUALITY_GATE_PREVIEW) + '…' : newStr;
-                diffContext = `\n## 本次变更摘要（Edit 操作）\n旧内容：\n\`\`\`\n${oldPreview}\n\`\`\`\n新内容：\n\`\`\`\n${newPreview}\n\`\`\``;
-            }
-        }
-        // 截断阈值，避免大文件被截断导致误判
-        const truncatedContent = content.length > TRUNCATION.QUALITY_GATE_CONTENT
-            ? content.substring(0, TRUNCATION.QUALITY_GATE_CONTENT) + '\n... (内容已截断，请基于已见部分判断)'
-            : content;
-        const prompt = PromptRegistry.load('quality-phase-review', {
-            toolName,
-            filePath,
-            content: truncatedContent,
-            requirementSection,
-            mandatoryNote,
-            conventionNote,
-            suppressedSection,
-            taskTypeNote,
-            diffContext,
-        });
-        // 最多重试 2 次（首次 + 1 次重试）
-        for (let attempt = 1; attempt <= 2; attempt++) {
-            try {
-                const response = await this.api.complete(prompt, 'quality-gate-phase');
-                const result = this.parseResult(response, filePath);
-                logger.info(`[Forge:质量检查] ${PHASE_LABELS[phase]}阶段代码检查完成：${result.level} — ${result.summary}`);
-                return result;
-            }
-            catch (err) {
-                if (attempt < 2) {
-                    logger.warn(`[Forge:质量检查] ${PHASE_LABELS[phase]}阶段代码检查出错（第 ${attempt} 次），正在重试：${err}`);
-                    await new Promise(r => setTimeout(r, TIME.THREE_SECONDS));
-                }
-                else {
-                    // 两次均失败：返回 null 放行（fail-safe），避免 AI 故障导致 Pipeline 永久阻断
-                    logger.warn(`[Forge:质量检查] ${PHASE_LABELS[phase]}阶段代码检查连续失败，跳过检查继续推进：${err}`);
-                    return null;
-                }
-            }
-        }
-        // TypeScript 要求：实际不可达，但需要返回值
-        return null;
-    }
-    getMandatoryCategoriesForPhase(phase) {
-        // documentation 类型：只检查 spec（文档完整性），不检查 test/security/performance
-        if (this.currentTaskType === 'documentation') {
-            switch (phase) {
-                case 'analyze': return ['spec'];
-                case 'design': return ['spec', 'quality'];
-                default: return [];
-            }
-        }
-        switch (phase) {
-            case 'analyze': return ['spec'];
-            case 'design': return ['spec', 'quality'];
-            case 'code': return ['security', 'quality'];
-            case 'test': return ['test'];
-            case 'review': return ['security', 'quality', 'spec', 'test'];
-            default: return [];
-        }
-    }
-    /**
-     * 主动修复循环：根据修复尝试次数决定响应策略
-     * - attempts 1-2：生成修复指令（注入 directive），让 Claude 自己修
-     * - attempts >= 3：生成 Forge 强制介入指令，标记 forgeFixApplied
-     * 返回附加的 directive 字符串（或 undefined）
-     */
-    handleFailIssue(issueId, attempts, result, filePath) {
-        const failChecks = result.checks.filter(c => c.level === 'fail');
-        if (failChecks.length === 0)
-            return undefined;
-        if (attempts <= 2) {
-            // 第 1-2 次：提示优先级升级，让 Claude 专注修复
-            return `[Forge 质量追踪] 该问题已发现 ${attempts} 次，优先修复后再继续其他工作。`;
-        }
-        // 第 3 次及以上：Forge 强制介入提示
-        this.issueTracker.markForgeFixed(issueId);
-        const fileRef = filePath ? `文件：${filePath}\n` : '';
-        return `[Forge 强制介入] 问题已持续 ${attempts} 次未解决，立即停止当前操作，专注修复以下问题：\n${fileRef}${failChecks.map(c => `- ${c.message}${c.suggestion ? `\n  修复方式：${c.suggestion}` : ''}`).join('\n')}`;
-    }
-    parseResult(response, filePath) {
-        const cleaned = response.replace(/```json\s*/g, '').replace(/```\s*/g, '');
-        const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
-        if (!jsonMatch) {
-            logger.warn(`[Forge:质量检查] AI 返回内容无法解析，跳过本次检查`);
-            logger.debug(`[Forge:质量检查] AI 原始返回：${response.slice(0, 300)}`);
-            throw new Error('AI response parse failed');
-        }
-        const parsed = JSON.parse(jsonMatch[0]);
-        const rawChecks = (parsed.checks || []).map((c) => ({
-            category: c.category || 'quality',
-            level: c.level || 'pass',
-            message: c.message || '',
-            suggestion: c.suggestion,
-        }));
-        // 抑制过滤：真正过滤掉已抑制类别的 warn 级别问题
-        // Convention must 规范来源的 fail 永不抑制（conventionName 字段标记）
-        const suppressedCategories = new Set(this.skipPatterns.keys());
-        const mustConventionCategories = new Set(this.conventionStandards.filter(s => s.severity === 'must').map(s => s.category));
-        const filteredChecks = suppressedCategories.size > 0
-            ? rawChecks.filter(c => {
-                if (c.level === 'pass')
-                    return true;
-                // Convention must 规范对应的类别永不抑制
-                if (mustConventionCategories.has(c.category))
-                    return true;
-                // 已抑制类别的 warn 过滤掉；fail 保留（用户明确忽略 N 次后才抑制，说明确实不重要）
-                if (suppressedCategories.has(c.category) && c.level === 'warn')
-                    return false;
-                return true;
-            })
-            : rawChecks;
-        // 重新计算整体 level（过滤后）
-        const effectiveLevel = filteredChecks.some(c => c.level === 'fail') ? 'fail'
-            : filteredChecks.some(c => c.level === 'warn') ? 'warn' : 'pass';
-        // 检查是否违反 must 规范（硬阻断条件）
-        // 匹配策略：以 category 为主键。AI 审查返回的 check.category 与 Convention
-        // quality_standards 的 category 共享同一枚举空间（spec/security/quality/test/performance），
-        // 只要 fail 级别的 check.category 命中任意 must 规范的 category，即视为违反。
-        const mustRules = this.conventionStandards.filter(s => s.severity === 'must');
-        const criticalIssues = [];
-        let hasBlockingIssue = false;
-        if (effectiveLevel === 'fail' && mustRules.length > 0) {
-            // 收集所有 fail 级别 check 命中的 must 规范（按 category 精确匹配，去重）
-            const seenCategories = new Set();
-            for (const check of filteredChecks.filter(c => c.level === 'fail')) {
-                const matchedRules = mustRules.filter(r => r.category === check.category);
-                for (const matchedRule of matchedRules) {
-                    const dedupeKey = `${matchedRule.category}:${matchedRule.rule}`;
-                    if (!seenCategories.has(dedupeKey)) {
-                        seenCategories.add(dedupeKey);
-                        hasBlockingIssue = true;
-                        criticalIssues.push({
-                            category: matchedRule.category,
-                            rule: matchedRule.rule,
-                            conventionName: matchedRule.conventionName,
-                        });
-                    }
-                }
-            }
-        }
-        const result = {
-            level: effectiveLevel,
-            checks: filteredChecks,
-            summary: parsed.summary || '审查完成',
-            blocking: hasBlockingIssue, // ✅ 设置硬阻断标记
-            criticalIssues: criticalIssues.length > 0 ? criticalIssues : undefined,
-        };
-        // 生成 directive
-        result.directive = this.generateDirective(result, filePath) || undefined;
-        // 如果本次审查通过，将同一文件的历史 fail 标记为已解决
-        if (result.level === 'pass') {
-            for (const h of this.reviewHistory) {
-                if (h.filePath === filePath && h.result.level === 'fail' && !h.resolved) {
-                    h.resolved = true;
-                    logger.debug(`[质量门禁] ${filePath} 审查通过，历史 fail 已标记为已解决`);
-                }
-            }
-            // 同步更新 issueTracker：将该文件的 open 问题标记为 resolved
-            if (this.currentPipelineId) {
-                const openIssues = this.issueTracker.getAll(this.currentPipelineId)
-                    .filter(i => i.filePath === filePath && (i.status === 'open' || i.status === 'in_progress'));
-                for (const issue of openIssues) {
-                    this.issueTracker.resolve(issue.id, 'code');
-                }
-            }
-        }
-        // 记录历史（环形缓冲，防止内存无限增长）
-        // accepted: fail 时为 false，供 feedback() 统计误报率
-        this.reviewHistory.push({ result, accepted: result.level !== 'fail', filePath, resolved: false });
-        if (this.reviewHistory.length > QualityGateEngine.MAX_HISTORY_LENGTH) {
-            this.reviewHistory = this.reviewHistory.slice(-QualityGateEngine.MAX_HISTORY_LENGTH);
-        }
-        // 结构化日志：本次审查结果
-        const passCount = result.checks.filter(c => c.level === 'pass').length;
-        const warnCount = result.checks.filter(c => c.level === 'warn').length;
-        const failCount = result.checks.filter(c => c.level === 'fail').length;
-        logger.info(`[Forge:质量检查] ${filePath} | 通过=${passCount} 警告=${warnCount} 不通过=${failCount}`);
-        // 累计统计降级为 debug（避免与阶段进度混淆）
-        const totalPass = this.reviewHistory.filter(h => h.result.level === 'pass' || h.result.level === 'warn').length;
-        const passRate = this.reviewHistory.length > 0 ? Math.round((totalPass / this.reviewHistory.length) * 100) : 0;
-        logger.debug(`[质量门禁] 会话统计：累计通过率 ${passRate}% (${totalPass}/${this.reviewHistory.length})`);
-        return result;
-    }
-}
-//# sourceMappingURL=quality-gate.js.map