@spaceflow/review 0.77.0 → 0.79.0

package/dist/index.js

@@ -1,6 +1,6 @@
 import { LlmJsonPut, REVIEW_STATE, addLocaleResources, calculateNewLineNumber, createStreamLoggerState, defineExtension, logStreamEvent, normalizeVerbose, parallel, parseChangedLinesFromPatch, parseDiffText, parseHunksFromPatch, parseRepoUrl, parseVerbose, shouldLog, t, z } from "@spaceflow/core";
 import { access, mkdir, readFile, readdir, writeFile } from "fs/promises";
-import { basename, dirname, extname, isAbsolute, join, relative } from "path";
+import { basename, dirname, extname, isAbsolute, join, normalize, relative } from "path";
 import { homedir } from "os";
 import { execSync, spawn } from "child_process";
 import micromatch_0 from "micromatch";
@@ -182,6 +182,148 @@ const SEVERITY_EMOJI = {
 
 ;// CONCATENATED MODULE: external "micromatch"
 
+;// CONCATENATED MODULE: ./src/review-includes-filter.ts
+
+const CODE_BLOCK_TYPES = [
+    "function",
+    "class",
+    "interface",
+    "type",
+    "method"
+];
+/** status 值到前缀的映射（兼容 GitHub/GitLab/Gitea 各平台） */ const STATUS_ALIAS = {
+    added: "added",
+    created: "added",
+    renamed: "modified",
+    modified: "modified",
+    changed: "modified",
+    removed: "deleted",
+    deleted: "deleted"
+};
+/**
+ * 解析单条 include 模式，拆分 status 前缀和 glob。
+ *
+ * 只有当 `|` 前面的部分是已知 status 关键字时才视为前缀，否则当作普通 glob 处理（容错），
+ * 这样可以避免误解析 extglob 语法中含 `|` 的模式（如 `+(*.ts|*.js)`）。
+ * 排除模式（以 `!` 开头）始终作为普通 glob 处理。
+ */ function parseIncludePattern(pattern) {
+    if (pattern.startsWith("!")) {
+        return {
+            status: undefined,
+            glob: pattern
+        };
+    }
+    const separatorIndex = pattern.indexOf("|");
+    if (separatorIndex === -1) {
+        return {
+            status: undefined,
+            glob: pattern
+        };
+    }
+    const prefix = pattern.slice(0, separatorIndex).trim().toLowerCase();
+    const glob = pattern.slice(separatorIndex + 1).trim();
+    const status = STATUS_ALIAS[prefix];
+    if (!status) {
+        // 前缀无法识别（如 extglob 中的 `|`），当作普通 glob 处理
+        return {
+            status: undefined,
+            glob: pattern
+        };
+    }
+    return {
+        status,
+        glob
+    };
+}
+/**
+ * 根据 includes 模式列表过滤文件，支持 `status|glob` 前缀语法。
+ *
+ * 算法：
+ * 1. 将 includes 拆分为：排除模式(`!`)、无前缀正向 glob、有 status 前缀 glob
+ * 2. 每个文件先检查是否命中任意正向条件（无前缀 glob 或匹配 status 的前缀 glob）
+ * 3. 最后用排除模式做全局过滤（排除模式始终优先）
+ *
+ * @param files     待过滤的文件列表
+ * @param includes  include 模式列表，支持 `added|*.ts`、`modified|*.ts`、`deleted|*.ts` 前缀
+ * @returns         匹配的文件列表
+ */ function filterFilesByIncludes(files, includes) {
+    if (!includes || includes.length === 0) return files;
+    const parsed = includes.map(parseIncludePattern);
+    console.log(`[filterFilesByIncludes] parsed patterns=${JSON.stringify(parsed)}`);
+    // 排除模式（以 ! 开头），用于最终全局过滤
+    const negativeGlobs = parsed.filter((p)=>p.status === undefined && p.glob.startsWith("!")).map((p)=>p.glob.slice(1)); // 去掉 ! 前缀，用 micromatch.not 处理
+    // 无前缀的正向 globs
+    const plainGlobs = parsed.filter((p)=>p.status === undefined && !p.glob.startsWith("!")).map((p)=>p.glob);
+    // 有 status 前缀的 patterns
+    const statusPatterns = parsed.filter((p)=>p.status !== undefined);
+    console.log(`[filterFilesByIncludes] negativeGlobs=${JSON.stringify(negativeGlobs)}, plainGlobs=${JSON.stringify(plainGlobs)}, statusPatterns=${JSON.stringify(statusPatterns)}`);
+    return files.filter((file)=>{
+        const filename = file.filename ?? "";
+        const fileStatus = STATUS_ALIAS[file.status?.toLowerCase() ?? ""] ?? "modified";
+        if (!filename) return false;
+        // 最终排除：命中排除模式的文件直接过滤掉
+        if (negativeGlobs.length > 0 && micromatch_0.isMatch(filename, negativeGlobs, {
+            matchBase: true
+        })) {
+            console.log(`[filterFilesByIncludes] ${filename} excluded by negativeGlobs`);
+            return false;
+        }
+        // 正向匹配：无前缀 glob
+        if (plainGlobs.length > 0 && micromatch_0.isMatch(filename, plainGlobs, {
+            matchBase: true
+        })) {
+            console.log(`[filterFilesByIncludes] ${filename} matched plainGlobs`);
+            return true;
+        }
+        // 正向匹配：有 status 前缀的 glob，按文件实际 status 过滤
+        // glob 可以带 ! 前缀表示在该 status 范围内排除，如 added|!**/*.spec.ts
+        if (statusPatterns.length > 0) {
+            // 按 status 分组，每组内正向 glob + 排除 glob 合并后批量匹配
+            const matchingStatusGlobs = statusPatterns.filter(({ status })=>status === fileStatus).map(({ glob })=>glob);
+            if (matchingStatusGlobs.length > 0) {
+                // 有正向 glob 才有意义，纯排除 glob 组合 micromatch 会视为全匹配再排除
+                const positiveGlobs = matchingStatusGlobs.filter((g)=>!g.startsWith("!"));
+                const negativeStatusGlobs = matchingStatusGlobs.filter((g)=>g.startsWith("!")).map((g)=>g.slice(1));
+                if (positiveGlobs.length > 0) {
+                    const matchesPositive = micromatch_0.isMatch(filename, positiveGlobs, {
+                        matchBase: true
+                    });
+                    const matchesNegative = negativeStatusGlobs.length > 0 && micromatch_0.isMatch(filename, negativeStatusGlobs, {
+                        matchBase: true
+                    });
+                    if (matchesPositive && !matchesNegative) {
+                        console.log(`[filterFilesByIncludes] ${filename} (status=${fileStatus}) matched statusPatterns`);
+                        return true;
+                    }
+                }
+            }
+        }
+        console.log(`[filterFilesByIncludes] ${filename} (status=${fileStatus}) NOT matched`);
+        return false;
+    });
+}
+/**
+ * 从 includes 模式列表中提取纯 glob（用于 commit 过滤，commit 没有 status 概念）。
+ * 带 status 前缀的模式会去掉前缀，仅保留 glob 部分。
+ */ function extractGlobsFromIncludes(includes) {
+    return includes.map((p)=>parseIncludePattern(p).glob).filter((g)=>g.length > 0);
+}
+/**
+ * 从 whenModifiedCode 配置中解析代码结构过滤类型。
+ * 只接受简单的类型名称，如 "function"、"class"、"interface"、"type"、"method"
+ */ function extractCodeBlockTypes(whenModifiedCode) {
+    const types = new Set();
+    for (const entry of whenModifiedCode){
+        const trimmed = entry.trim();
+        if (CODE_BLOCK_TYPES.includes(trimmed)) {
+            types.add(trimmed);
+        }
+    }
+    return [
+        ...types
+    ];
+}
+
 ;// CONCATENATED MODULE: ./src/review-spec/review-spec.service.ts
 
 
@@ -189,6 +331,7 @@ const SEVERITY_EMOJI = {
 
 
 
+
 /** 远程规则缓存 TTL（毫秒），默认 5 分钟 */ const REMOTE_SPEC_CACHE_TTL = 5 * 60 * 1000;
 class ReviewSpecService {
     gitProvider;
@@ -237,7 +380,19 @@ class ReviewSpecService {
                 }
             }
         }
-        return specs.filter((spec)=>spec.extensions.some((ext)=>changedExtensions.has(ext)));
+        console.log(`[filterApplicableSpecs] changedExtensions=${JSON.stringify([
+            ...changedExtensions
+        ])}, specs count=${specs.length}`);
+        const result = specs.filter((spec)=>{
+            const matches = spec.extensions.some((ext)=>changedExtensions.has(ext));
+            if (!matches) {
+                console.log(`[filterApplicableSpecs] spec ${spec.filename} (ext: ${JSON.stringify(spec.extensions)}) NOT matched`);
+            } else {
+                console.log(`[filterApplicableSpecs] spec ${spec.filename} (ext: ${JSON.stringify(spec.extensions)}) MATCHED`);
+            }
+            return matches;
+        });
+        return result;
     }
     async loadReviewSpecs(specDir) {
         const specs = [];
@@ -623,8 +778,10 @@ class ReviewSpecService {
             if (includes.length === 0) {
                 return true;
             }
-            // 检查文件是否匹配 includes 模式
-            const matches = micromatch_0.isMatch(issue.file, includes, {
+            // 检查文件是否匹配 includes 模式（转换为纯 glob，避免 status| 前缀和 code-* 空串传入 micromatch）
+            const globs = extractGlobsFromIncludes(includes);
+            if (globs.length === 0) return true;
+            const matches = micromatch_0.isMatch(issue.file, globs, {
                 matchBase: true
             });
             if (!matches) {
@@ -719,8 +876,10 @@ class ReviewSpecService {
                 if (scoped.includes.length === 0) {
                     return true;
                 }
-                // 使用 micromatch 检查文件是否匹配 includes 模式
-                return issueFile && micromatch_0.isMatch(issueFile, scoped.includes, {
+                // 使用 micromatch 检查文件是否匹配 includes 模式（转换为纯 glob）
+                const globs = extractGlobsFromIncludes(scoped.includes);
+                if (globs.length === 0) return true;
+                return issueFile && micromatch_0.isMatch(issueFile, globs, {
                     matchBase: true
                 });
             });
@@ -1749,7 +1908,7 @@ class ReviewReportService {
     }
 }
 
-;// CONCATENATED MODULE: ./src/review-pr-comment-utils.ts
+;// CONCATENATED MODULE: ./src/utils/review-pr-comment.ts
 const REVIEW_COMMENT_MARKER = "<!-- spaceflow-review -->";
 const REVIEW_LINE_COMMENTS_MARKER = "<!-- spaceflow-review-lines -->";
 /**
@@ -2163,8 +2322,24 @@ function generateIssueKey(issue) {
             // 遍历每个评论，获取其 reactions
             for (const comment of reviewComments){
                 if (!comment.id) continue;
-                // 找到对应的 issue
-                const matchedIssue = this._result.issues.find((issue)=>issue.file === comment.path && this.lineMatchesPosition(issue.line, comment.position));
+                // 找到对应的 issue：优先通过 issue-key 精确匹配，回退到 path+line 匹配
+                let matchedIssue;
+                if (comment.body) {
+                    const issueKey = extractIssueKeyFromBody(comment.body);
+                    if (issueKey) {
+                        matchedIssue = this._result.issues.find((issue)=>generateIssueKey(issue) === issueKey);
+                        if (shouldLog(verbose, 3)) {
+                            console.log(`[syncReactionsToIssues] comment ${comment.id}: issue-key=${issueKey}, matched=${matchedIssue ? "yes" : "no"}`);
+                        }
+                    }
+                }
+                // 如果 issue-key 匹配失败，使用 path+position 回退匹配
+                if (!matchedIssue) {
+                    matchedIssue = this._result.issues.find((issue)=>issue.file === comment.path && this.lineMatchesPosition(issue.line, comment.position));
+                    if (shouldLog(verbose, 3)) {
+                        console.log(`[syncReactionsToIssues] comment ${comment.id}: fallback matching path=${comment.path}, position=${comment.position}, matched=${matchedIssue ? "yes" : "no"}`);
+                    }
+                }
                 if (matchedIssue) {
                     commentIdToIssue.set(comment.id, matchedIssue);
                 }
@@ -2783,6 +2958,7 @@ function generateIssueKey(issue) {
         references: z.array(z.string()).optional(),
         llmMode: llmModeSchema.default("openai").optional(),
         includes: z.array(z.string()).optional(),
+        whenModifiedCode: z.array(z.string()).optional(),
         rules: z.record(z.string(), severitySchema).optional(),
         verifyFixes: z.boolean().default(false),
         verifyFixesConcurrency: z.number().default(10).optional(),
@@ -2796,14 +2972,27 @@ function generateIssueKey(issue) {
         retries: z.number().default(0).optional(),
         retryDelay: z.number().default(1000).optional(),
         invalidateChangedFiles: invalidateChangedFilesSchema.default("invalidate").optional(),
-        skipDuplicateWorkflow: z.boolean().default(false).optional(),
+        duplicateWorkflowResolved: z["enum"]([
+            "off",
+            "skip",
+            "delete"
+        ]).default("delete").optional(),
         autoApprove: z.boolean().default(false).optional(),
         failOnIssues: z["enum"]([
             "off",
             "warn",
             "error",
             "warn+error"
-        ]).default("off").optional()
+        ]).default("off").optional(),
+        systemRules: z.object({
+            maxLinesPerFile: z.tuple([
+                z.number(),
+                severitySchema
+            ]).transform((v)=>[
+                    v[0],
+                    v[1]
+                ]).optional()
+        }).optional()
     });
 
 ;// CONCATENATED MODULE: ./src/parse-title-options.ts
@@ -2988,6 +3177,9 @@ class ReviewContextBuilder {
     }
     async getContextFromEnv(options) {
         const reviewConf = this.config.getPluginConfig("review");
+        if (shouldLog(options.verbose, 2)) {
+            console.log(`[getContextFromEnv] reviewConf: ${JSON.stringify(reviewConf)}`);
+        }
         const ciConf = this.config.get("ci");
         const repository = ciConf?.repository;
         if (options.ci) {
@@ -3047,11 +3239,14 @@ class ReviewContextBuilder {
         if (reviewConf.references?.length) {
             specSources.push(...reviewConf.references);
         }
+        const normalizedFiles = this.normalizeFilePaths(options.files);
         // 解析本地模式：非 CI、非 PR、无 base/head 时默认启用 uncommitted 模式
+        // 当显式指定 files 时，强制走“按文件审查模式”，不进入本地未提交模式
         const localMode = this.resolveLocalMode(options, {
             ci: options.ci,
             hasPrNumber: !!prNumber,
-            hasBaseHead: !!(options.base || options.head)
+            hasBaseHead: !!(options.base || options.head),
+            hasFiles: !!normalizedFiles?.length
         });
         // 当没有 PR 且没有指定 base/head 且不是本地模式时，自动获取默认值
         let baseRef = options.base;
@@ -3064,6 +3259,10 @@ class ReviewContextBuilder {
             }
         }
         // 合并参数优先级：命令行 > PR 标题 > 配置文件 > 默认值
+        const ctxIncludes = options.includes ?? titleOptions.includes ?? reviewConf.includes;
+        if (shouldLog(options.verbose, 2)) {
+            console.log(`[getContextFromEnv] includes: commandLine=${JSON.stringify(options.includes)}, title=${JSON.stringify(titleOptions.includes)}, config=${JSON.stringify(reviewConf.includes)}, final=${JSON.stringify(ctxIncludes)}`);
+        }
         return {
             owner,
             repo,
@@ -3074,9 +3273,10 @@ class ReviewContextBuilder {
             dryRun: options.dryRun || titleOptions.dryRun || false,
             ci: options.ci ?? false,
             verbose: normalizeVerbose(options.verbose ?? titleOptions.verbose),
-            includes: options.includes ?? titleOptions.includes ?? reviewConf.includes,
+            includes: ctxIncludes,
+            whenModifiedCode: options.whenModifiedCode ?? reviewConf.whenModifiedCode,
             llmMode: options.llmMode ?? titleOptions.llmMode ?? reviewConf.llmMode,
-            files: this.normalizeFilePaths(options.files),
+            files: normalizedFiles,
             commits: options.commits,
             verifyFixes: options.verifyFixes ?? titleOptions.verifyFixes ?? reviewConf.verifyFixes ?? true,
             verifyConcurrency: options.verifyConcurrency ?? reviewConf.verifyFixesConcurrency ?? 10,
@@ -3095,8 +3295,9 @@ class ReviewContextBuilder {
             flush: options.flush ?? false,
             eventAction: options.eventAction,
             localMode,
-            skipDuplicateWorkflow: options.skipDuplicateWorkflow ?? reviewConf.skipDuplicateWorkflow ?? false,
-            autoApprove: options.autoApprove ?? reviewConf.autoApprove ?? false
+            duplicateWorkflowResolved: options.duplicateWorkflowResolved ?? reviewConf.duplicateWorkflowResolved ?? "delete",
+            autoApprove: options.autoApprove ?? reviewConf.autoApprove ?? false,
+            systemRules: options.systemRules ?? reviewConf.systemRules
         };
     }
     /**
@@ -3105,6 +3306,10 @@ class ReviewContextBuilder {
    * - 显式指定 --no-local 时禁用
    * - 非 CI、非 PR、无 base/head 时默认启用 uncommitted 模式
    */ resolveLocalMode(options, env) {
+        // 显式指定了 files，优先进入按文件审查模式
+        if (env.hasFiles) {
+            return false;
+        }
         // 显式指定了 --no-local
         if (options.local === false) {
             return false;
@@ -3130,13 +3335,17 @@ class ReviewContextBuilder {
    */ normalizeFilePaths(files) {
         if (!files || files.length === 0) return files;
         const cwd = process.cwd();
-        return files.map((file)=>{
-            if (isAbsolute(file)) {
-                // 绝对路径转换为相对路径
-                return relative(cwd, file);
-            }
-            return file;
-        });
+        return files.map((file)=>this.normalizeSingleFilePath(file, cwd));
+    }
+    /**
+   * 规范化单个文件路径为仓库相对路径：
+   * - 绝对路径转相对路径
+   * - 统一分隔符为 /
+   * - 移除前导 ./
+   */ normalizeSingleFilePath(file, cwd) {
+        const normalizedInput = normalize(file);
+        const relativePath = isAbsolute(normalizedInput) ? relative(cwd, normalizedInput) : normalizedInput;
+        return relativePath.replaceAll("\\", "/").replace(/^\.\/+/, "");
     }
     /**
    * 根据 AnalyzeDeletionsMode 和当前环境解析是否启用删除代码分析
@@ -3268,13 +3477,32 @@ class ReviewContextBuilder {
         // 为每个 issue 填充 author
         return issues.map((issue)=>{
             if (issue.author) {
+                const shortHash = issue.commit?.slice(0, 7);
+                if (shortHash?.includes("---")) {
+                    return {
+                        ...issue,
+                        commit: undefined,
+                        valid: "false"
+                    };
+                }
                 if (shouldLog(verbose, 2)) {
                     console.log(`[fillIssueAuthors] issue already has author: ${issue.author.login}`);
                 }
                 return issue;
             }
             const shortHash = issue.commit?.slice(0, 7);
-            const author = shortHash && !shortHash.includes("---") ? commitAuthorMap.get(shortHash) : undefined;
+            const isValidHash = Boolean(shortHash && !shortHash.includes("---"));
+            if (!isValidHash) {
+                if (shouldLog(verbose, 2)) {
+                    console.log(`[fillIssueAuthors] issue: file=${issue.file}, commit=${issue.commit} is invalid hash, marking as invalid`);
+                }
+                return {
+                    ...issue,
+                    commit: undefined,
+                    valid: "false"
+                };
+            }
+            const author = commitAuthorMap.get(shortHash);
             if (shouldLog(verbose, 2)) {
                 console.log(`[fillIssueAuthors] issue: file=${issue.file}, commit=${issue.commit}, shortHash=${shortHash}, foundAuthor=${author?.login}, finalAuthor=${(author || defaultAuthor)?.login}`);
             }
@@ -3677,125 +3905,139 @@ class ReviewIssueFilter {
     }
 }
 
-;// CONCATENATED MODULE: ./src/review-includes-filter.ts
-
-/** status 值到前缀的映射（兼容 GitHub/GitLab/Gitea 各平台） */ const STATUS_ALIAS = {
-    added: "added",
-    created: "added",
-    renamed: "modified",
-    modified: "modified",
-    changed: "modified",
-    removed: "deleted",
-    deleted: "deleted"
-};
+;// CONCATENATED MODULE: ./src/utils/review-llm.ts
 /**
- * 解析单条 include 模式，拆分 status 前缀和 glob。
+ * 构建带行号的文件内容字符串。
  *
- * 只有当 `|` 前面的部分是已知 status 关键字时才视为前缀，否则当作普通 glob 处理（容错），
- * 这样可以避免误解析 extglob 语法中含 `|` 的模式（如 `+(*.ts|*.js)`）。
- * 排除模式（以 `!` 开头）始终作为普通 glob 处理。
- */ function parseIncludePattern(pattern) {
-    if (pattern.startsWith("!")) {
-        return {
-            status: undefined,
-            glob: pattern
-        };
+ * @param contentLines  [hash, code] 行数组
+ * @param visibleRanges 可选，指定需要输出的行号区间 [startLine, endLine]（不含则输出全文）
+ *                      被跳过的连续行用 `...... ..| ignore {start}-{end} code` 占位
+ */ function buildLinesWithNumbers(contentLines, visibleRanges) {
+    const padWidth = String(contentLines.length).length;
+    if (!visibleRanges || visibleRanges.length === 0) {
+        return contentLines.map(([hash, line], index)=>{
+            const lineNum = index + 1;
+            return `${hash} ${String(lineNum).padStart(padWidth)}| ${line}`;
+        }).join("\n");
     }
-    const separatorIndex = pattern.indexOf("|");
-    if (separatorIndex === -1) {
-        return {
-            status: undefined,
-            glob: pattern
-        };
+    // 将 ranges 按起始行号排序并合并重叠区间
+    const sorted = [
+        ...visibleRanges
+    ].sort((a, b)=>a[0] - b[0]);
+    const merged = [];
+    for (const range of sorted){
+        if (merged.length > 0 && range[0] <= merged[merged.length - 1][1] + 1) {
+            merged[merged.length - 1][1] = Math.max(merged[merged.length - 1][1], range[1]);
+        } else {
+            merged.push([
+                ...range
+            ]);
+        }
     }
-    const prefix = pattern.slice(0, separatorIndex).trim().toLowerCase();
-    const glob = pattern.slice(separatorIndex + 1).trim();
-    const status = STATUS_ALIAS[prefix];
-    if (!status) {
-        // 前缀无法识别（如 extglob 中的 `|`），当作普通 glob 处理
-        return {
-            status: undefined,
-            glob: pattern
-        };
+    const output = [];
+    let prevEnd = 0;
+    for (const [start, end] of merged){
+        const clampedStart = Math.max(1, start);
+        const clampedEnd = Math.min(contentLines.length, end);
+        // 被忽略的前缀区间
+        if (clampedStart > prevEnd + 1) {
+            output.push(`....... ignore ${prevEnd + 1}-${clampedStart - 1} line .......`);
+        }
+        // 输出可见行
+        for(let i = clampedStart - 1; i < clampedEnd; i++){
+            const [hash, line] = contentLines[i];
+            const lineNum = i + 1;
+            output.push(`${hash} ${String(lineNum).padStart(padWidth)}| ${line}`);
+        }
+        prevEnd = clampedEnd;
     }
-    return {
-        status,
-        glob
-    };
+    // 被忽略的末尾区间
+    if (prevEnd < contentLines.length) {
+        output.push(`....... ignore ${prevEnd + 1}-${contentLines.length} line .......`);
+    }
+    return output.join("\n");
 }
 /**
- * 根据 includes 模式列表过滤文件，支持 `status|glob` 前缀语法。
+ * 从 contentLines 中提取新增代码里的指定结构类型的行号范围。
  *
- * 算法：
- * 1. 将 includes 拆分为：排除模式(`!`)、无前缀正向 glob、有 status 前缀 glob
- * 2. 每个文件先检查是否命中任意正向条件（无前缀 glob 或匹配 status 的前缀 glob）
- * 3. 最后用排除模式做全局过滤（排除模式始终优先）
+ * 逻辑：
+ * 1. 只考虑 hash !== "-------" 的新增行
+ * 2. 用各类型的正则匹配结构开头行，再用层级计数找到结尾行
+ * 3. 返回行号范围列表 [startLine, endLine]（从 1 计）
  *
- * @param files     待过滤的文件列表
- * @param includes  include 模式列表，支持 `added|*.ts`、`modified|*.ts`、`deleted|*.ts` 前缀
- * @returns         匹配的文件列表
- */ function filterFilesByIncludes(files, includes) {
-    if (!includes || includes.length === 0) return files;
-    const parsed = includes.map(parseIncludePattern);
-    // 排除模式（以 ! 开头），用于最终全局过滤
-    const negativeGlobs = parsed.filter((p)=>p.status === undefined && p.glob.startsWith("!")).map((p)=>p.glob.slice(1)); // 去掉 ! 前缀，用 micromatch.not 处理
-    // 无前缀的正向 globs
-    const plainGlobs = parsed.filter((p)=>p.status === undefined && !p.glob.startsWith("!")).map((p)=>p.glob);
-    // 有 status 前缀的 patterns
-    const statusPatterns = parsed.filter((p)=>p.status !== undefined);
-    return files.filter((file)=>{
-        const filename = file.filename ?? "";
-        if (!filename) return false;
-        // 最终排除：命中排除模式的文件直接过滤掉
-        if (negativeGlobs.length > 0 && micromatch_0.isMatch(filename, negativeGlobs, {
-            matchBase: true
-        })) {
-            return false;
-        }
-        // 正向匹配：无前缀 glob
-        if (plainGlobs.length > 0 && micromatch_0.isMatch(filename, plainGlobs, {
-            matchBase: true
-        })) {
-            return true;
+ * @param contentLines  文件的 [hash, code] 行列表
+ * @param types         要提取的结构类型
+ */ function extractCodeBlocks(contentLines, types) {
+    if (types.length === 0) return [];
+    const ranges = [];
+    // 将所有行的实际代码组成文本（用于层级计数）
+    const fullLines = contentLines.map(([, code])=>code);
+    // 各类型的开头識别正则（匹配行首）
+    const PATTERNS = {
+        function: /^\s*(?:export\s+)?(?:async\s+)?function\s+\w+/,
+        class: /^\s*(?:export\s+)?(?:abstract\s+)?class\s+\w+/,
+        interface: /^\s*(?:export\s+)?interface\s+\w+/,
+        type: /^\s*(?:export\s+)?type\s+\w+\s*[=<]/,
+        method: /^\s*(?:(?:public|protected|private|static|async|override|readonly|abstract)\s+)*(?!(?:if|for|while|switch|return|const|let|var|throw|new)\b)(\w+)\s*[(<]/
+    };
+    for(let i = 0; i < fullLines.length; i++){
+        const lineNum = i + 1;
+        const isAdded = contentLines[i][0] !== "-------";
+        if (!isAdded) continue;
+        for (const type of types){
+            const pattern = PATTERNS[type];
+            if (!pattern.test(fullLines[i])) continue;
+            // 找到结构开头，用层级计数找封闭括号结尾
+            const endLine = findBlockEnd(fullLines, i);
+            ranges.push([
+                lineNum,
+                endLine
+            ]);
+            break; // 同一行只匹配一种类型
         }
-        // 正向匹配：有 status 前缀的 glob，按文件实际 status 过滤
-        // glob 可以带 ! 前缀表示在该 status 范围内排除，如 added|!**/*.spec.ts
-        if (statusPatterns.length > 0) {
-            const fileStatus = STATUS_ALIAS[file.status?.toLowerCase() ?? ""] ?? "modified";
-            // 按 status 分组，每组内正向 glob + 排除 glob 合并后批量匹配
-            const matchingStatusGlobs = statusPatterns.filter(({ status })=>status === fileStatus).map(({ glob })=>glob);
-            if (matchingStatusGlobs.length > 0) {
-                // 有正向 glob 才有意义，纯排除 glob 组合 micromatch 会视为全匹配再排除
-                const positiveGlobs = matchingStatusGlobs.filter((g)=>!g.startsWith("!"));
-                const negativeStatusGlobs = matchingStatusGlobs.filter((g)=>g.startsWith("!")).map((g)=>g.slice(1));
-                if (positiveGlobs.length > 0) {
-                    const matchesPositive = micromatch_0.isMatch(filename, positiveGlobs, {
-                        matchBase: true
-                    });
-                    const matchesNegative = negativeStatusGlobs.length > 0 && micromatch_0.isMatch(filename, negativeStatusGlobs, {
-                        matchBase: true
-                    });
-                    if (matchesPositive && !matchesNegative) return true;
+    }
+    return mergeRanges(ranges);
+}
+/**
+ * 从开始行向下层级计数，找到匹配的封闭括号位置（行号从 1 计）。
+ * 如果没有找到匹配括号，返回开始行到文件末尾。
+ */ function findBlockEnd(lines, startIndex) {
+    let depth = 0;
+    let foundOpen = false;
+    for(let i = startIndex; i < lines.length; i++){
+        for (const ch of lines[i]){
+            if (ch === "{") {
+                depth++;
+                foundOpen = true;
+            } else if (ch === "}") {
+                depth--;
+                if (foundOpen && depth === 0) {
+                    return i + 1; // 行号从 1 计
                 }
             }
         }
-        return false;
-    });
-}
-/**
- * 从 includes 模式列表中提取纯 glob（用于 commit 过滤，commit 没有 status 概念）。
- * 带 status 前缀的模式会去掉前缀，仅保留 glob 部分。
- */ function extractGlobsFromIncludes(includes) {
-    return includes.map((p)=>parseIncludePattern(p).glob);
+    }
+    return lines.length; // 没有找到匹配括号，返回文件末尾
 }
-
-;// CONCATENATED MODULE: ./src/utils/review-llm.ts
-function buildLinesWithNumbers(contentLines) {
-    const padWidth = String(contentLines.length).length;
-    return contentLines.map(([hash, line], index)=>{
-        const lineNum = index + 1;
-        return `${hash} ${String(lineNum).padStart(padWidth)}| ${line}`;
-    }).join("\n");
+function mergeRanges(ranges) {
+    if (ranges.length === 0) return [];
+    const sorted = [
+        ...ranges
+    ].sort((a, b)=>a[0] - b[0]);
+    const merged = [
+        sorted[0]
+    ];
+    for(let i = 1; i < sorted.length; i++){
+        const last = merged[merged.length - 1];
+        if (sorted[i][0] <= last[1] + 1) {
+            last[1] = Math.max(last[1], sorted[i][1]);
+        } else {
+            merged.push([
+                ...sorted[i]
+            ]);
+        }
+    }
+    return merged;
 }
 function buildCommitsSection(contentLines, commits) {
     const fileCommitHashes = new Set();
@@ -3811,13 +4053,10 @@ function buildCommitsSection(contentLines, commits) {
     return relatedCommits.length > 0 ? relatedCommits.map((c)=>`- \`${c.sha?.slice(0, 7)}\` ${c.commit?.message?.split("\n")[0]}`).join("\n") : "- 无相关 commits";
 }
 
-;// CONCATENATED MODULE: ./src/review-llm.ts
-
-
-
-
-
-const REVIEW_SCHEMA = {
+;// CONCATENATED MODULE: ./src/prompt/schemas.ts
+/**
+ * 代码审查结果 JSON Schema
+ */ const REVIEW_SCHEMA = {
     type: "object",
     properties: {
         issues: {
@@ -3883,6 +4122,532 @@ const REVIEW_SCHEMA = {
     ],
     additionalProperties: false
 };
+/**
+ * 删除影响分析结果 JSON Schema
+ */ const DELETION_IMPACT_SCHEMA = {
+    type: "object",
+    properties: {
+        impacts: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    file: {
+                        type: "string",
+                        description: "被删除代码所在的文件路径"
+                    },
+                    deletedCode: {
+                        type: "string",
+                        description: "被删除的代码片段摘要（前50字符）"
+                    },
+                    riskLevel: {
+                        type: "string",
+                        enum: [
+                            "high",
+                            "medium",
+                            "low",
+                            "none"
+                        ],
+                        description: "风险等级：high=可能导致功能异常，medium=可能影响部分功能，low=影响较小，none=无影响"
+                    },
+                    affectedFiles: {
+                        type: "array",
+                        items: {
+                            type: "string"
+                        },
+                        description: "可能受影响的文件列表"
+                    },
+                    reason: {
+                        type: "string",
+                        description: "影响分析的详细说明"
+                    },
+                    suggestion: {
+                        type: "string",
+                        description: "建议的处理方式"
+                    }
+                },
+                required: [
+                    "file",
+                    "deletedCode",
+                    "riskLevel",
+                    "affectedFiles",
+                    "reason"
+                ],
+                additionalProperties: false
+            }
+        },
+        summary: {
+            type: "string",
+            description: "删除代码影响的整体总结"
+        }
+    },
+    required: [
+        "impacts",
+        "summary"
+    ],
+    additionalProperties: false
+};
+/**
+ * 问题验证结果 JSON Schema
+ */ const VERIFY_SCHEMA = {
+    type: "object",
+    properties: {
+        fixed: {
+            type: "boolean",
+            description: "问题是否已被修复"
+        },
+        valid: {
+            type: "boolean",
+            description: "问题是否有效，有效的条件就是你需要看看代码是否符合规范"
+        },
+        reason: {
+            type: "string",
+            description: "判断依据，说明为什么认为问题已修复或仍存在"
+        }
+    },
+    required: [
+        "fixed",
+        "valid",
+        "reason"
+    ],
+    additionalProperties: false
+};
+
+;// CONCATENATED MODULE: ./src/prompt/types.ts
+/**
+ * 提示词回调函数类型定义
+ */ /**
+ * 输入验证错误类
+ */ class PromptValidationError extends Error {
+    constructor(message){
+        super(message);
+        this.name = "PromptValidationError";
+    }
+}
+/**
+ * 输入验证工具函数
+ */ function validateRequired(value, fieldName) {
+    if (value === undefined || value === null) {
+        throw new PromptValidationError(`${fieldName} is required but was ${value}`);
+    }
+    return value;
+}
+function types_validateNonEmptyString(value, fieldName) {
+    if (value === undefined || value === null || value.trim() === "") {
+        throw new PromptValidationError(`${fieldName} is required and cannot be empty`);
+    }
+    return value;
+}
+function validateArray(value, fieldName) {
+    if (!Array.isArray(value)) {
+        throw new PromptValidationError(`${fieldName} must be an array but was ${typeof value}`);
+    }
+    return value;
+}
+
+;// CONCATENATED MODULE: ./src/prompt/code-review.ts
+
+/**
+ * 代码审查公共系统提示词基础
+ */ const CODE_REVIEW_BASE_SYSTEM_PROMPT = `你是一个专业的代码审查专家，负责根据团队的编码规范对代码进行严格审查。
+
+## 审查要求
+
+1. **严格遵循规范**：只按照上述审查规范进行审查，不要添加规范之外的要求
+2. **精准定位问题**：每个问题必须指明具体的行号，行号从文件内容中的 "行号|" 格式获取
+3. **避免重复报告**：如果提示词中包含"上一次审查结果"，请不要重复报告已存在的问题
+4. **提供可行建议**：对于每个问题，提供具体的修改建议代码
+
+## 注意事项
+
+- 变更文件内容已在上下文中提供，无需调用读取工具
+- 你可以读取项目中的其他文件以了解上下文
+- 不要调用编辑工具修改文件，你的职责是审查而非修改
+- 文件内容格式为 "CommitHash 行号| 代码"，输出的 line 字段应对应原始行号
+
+## 输出要求
+
+- 发现问题时：在 issues 数组中列出所有问题，每个问题包含 file、line、ruleId、specFile、reason、suggestion、severity
+- 无论是否发现问题：都必须在 summary 中提供该文件的审查总结，简要说明审查结果`;
+const buildCodeReviewSystemPrompt = (ctx)=>{
+    validateNonEmptyString(ctx.specsSection, "specsSection");
+    return {
+        systemPrompt: `${CODE_REVIEW_BASE_SYSTEM_PROMPT}
+
+## 审查规范
+
+${ctx.specsSection}`,
+        userPrompt: ""
+    };
+};
+const buildFileReviewPrompt = (ctx)=>{
+    // 验证必需的输入参数
+    types_validateNonEmptyString(ctx.filename, "filename");
+    types_validateNonEmptyString(ctx.status, "status");
+    types_validateNonEmptyString(ctx.linesWithNumbers, "linesWithNumbers");
+    validateRequired(ctx.specsSection, "specsSection");
+    return {
+        systemPrompt: `${CODE_REVIEW_BASE_SYSTEM_PROMPT}
+
+## 审查规范
+
+${ctx.specsSection}`,
+        userPrompt: `## ${ctx.filename} (${ctx.status})
+
+### 文件内容
+
+\`\`\`
+${ctx.linesWithNumbers}
+\`\`\`
+
+### 该文件的相关 Commits
+
+${ctx.commitsSection}
+
+### 该文件所在的目录树
+
+${ctx.fileDirectoryInfo}
+
+### 上一次审查结果
+
+${ctx.previousReviewSection}`
+    };
+};
+
+;// CONCATENATED MODULE: ./src/prompt/pr-description.ts
+
+/**
+ * 内存使用限制常量
+ */ const MEMORY_LIMITS = {
+    MAX_TOTAL_LENGTH: 8000,
+    MAX_FILES: 30,
+    MAX_SNIPPET_LENGTH: 50,
+    MAX_COMMITS: 10,
+    MAX_FILES_FOR_TITLE: 20
+};
+const buildPrDescriptionPrompt = (ctx)=>{
+    // 验证必需的输入参数
+    validateArray(ctx.commits, "commits");
+    validateArray(ctx.changedFiles, "changedFiles");
+    const commitMessages = ctx.commits.map((c)=>`- ${c.sha?.slice(0, 7)}: ${c.commit?.message?.split("\n")[0]}`).join("\n");
+    const fileChanges = ctx.changedFiles.slice(0, MEMORY_LIMITS.MAX_FILES).map((f)=>`- ${f.filename} (${f.status})`).join("\n");
+    // 构建代码变更内容（只包含变更行，优化内存使用）
+    let codeChangesSection = "";
+    if (ctx.fileContents && ctx.fileContents.size > 0) {
+        const codeSnippets = [];
+        let totalLength = 0;
+        // 使用 Map.entries() 进行更高效的迭代
+        for (const [filename, lines] of ctx.fileContents){
+            if (totalLength >= MEMORY_LIMITS.MAX_TOTAL_LENGTH) break;
+            // 只提取有变更的行（commitHash 不是 "-------"）
+            const changedLines = lines.map(([hash, code], idx)=>hash !== "-------" ? `${idx + 1}: ${code}` : null).filter(Boolean);
+            if (changedLines.length > 0) {
+                // 限制每个文件的代码行数，避免单个文件占用过多内存
+                const limitedLines = changedLines.slice(0, MEMORY_LIMITS.MAX_SNIPPET_LENGTH);
+                const snippet = `### ${filename}\n\`\`\`\n${limitedLines.join("\n")}\n\`\`\``;
+                // 检查添加此片段是否会超过内存限制
+                if (totalLength + snippet.length <= MEMORY_LIMITS.MAX_TOTAL_LENGTH) {
+                    codeSnippets.push(snippet);
+                    totalLength += snippet.length;
+                } else {
+                    // 如果添加当前片段会超过限制，尝试截断它
+                    const remainingLength = MEMORY_LIMITS.MAX_TOTAL_LENGTH - totalLength;
+                    if (remainingLength > 100) {
+                        // 至少保留 100 字符的片段
+                        // snippet 格式为 "### filename\n```\ncode\n```"
+                        // 截断时去掉结尾的 ``` 再追加，避免双重代码块
+                        const closingTag = "\n```";
+                        const contentEnd = snippet.lastIndexOf(closingTag);
+                        const truncateAt = Math.max(0, contentEnd > 0 ? Math.min(remainingLength - 20, contentEnd) : remainingLength - 20);
+                        const truncatedSnippet = snippet.substring(0, truncateAt) + "\n..." + closingTag;
+                        codeSnippets.push(truncatedSnippet);
+                        break;
+                    }
+                    break;
+                }
+            }
+        }
+        if (codeSnippets.length > 0) {
+            codeChangesSection = `\n\n## 代码变更内容\n${codeSnippets.join("\n\n")}`;
+        }
+    }
+    return {
+        systemPrompt: "",
+        userPrompt: `请根据以下 PR 的 commit 记录、文件变更和代码内容，用简洁的中文总结这个 PR 实现了什么功能。
+要求：
+1. 第一行输出 PR 标题，格式必须是: Feat xxx 或 Fix xxx 或 Refactor xxx（根据变更类型选择，整体不超过 50 个字符）
+2. 空一行后输出详细描述
+3. 描述应该简明扼要，突出核心功能点
+4. 使用 Markdown 格式
+5. 不要逐条列出 commit，而是归纳总结
+6. 重点分析代码变更的实际功能
+
+## Commit 记录 (${ctx.commits.length} 个)
+${commitMessages || "无"}
+
+## 文件变更 (${ctx.changedFiles.length} 个文件)
+${fileChanges || "无"}${ctx.changedFiles.length > MEMORY_LIMITS.MAX_FILES ? `\n... 等 ${ctx.changedFiles.length - MEMORY_LIMITS.MAX_FILES} 个文件` : ""}${codeChangesSection}`
+    };
+};
+const buildPrTitlePrompt = (ctx)=>{
+    // 验证必需的输入参数
+    validateArray(ctx.commits, "commits");
+    validateArray(ctx.changedFiles, "changedFiles");
+    const commitMessages = ctx.commits.slice(0, MEMORY_LIMITS.MAX_COMMITS).map((c)=>c.commit?.message?.split("\n")[0]).filter(Boolean).join("\n");
+    const fileChanges = ctx.changedFiles.slice(0, MEMORY_LIMITS.MAX_FILES_FOR_TITLE).map((f)=>`${f.filename} (${f.status})`).join("\n");
+    return {
+        systemPrompt: "",
+        userPrompt: `请根据以下 commit 记录和文件变更，生成一个简短的 PR 标题。
+要求：
+1. 格式必须是: Feat: xxx 或 Fix: xxx 或 Refactor: xxx
+2. 根据变更内容选择合适的前缀（新功能用 Feat，修复用 Fix，重构用 Refactor）
+3. xxx 部分用简短的中文描述（整体不超过 50 个字符）
+4. 只输出标题，不要加任何解释
+
+Commit 记录:
+${commitMessages || "无"}
+
+文件变更:
+${fileChanges || "无"}`
+    };
+};
+
+;// CONCATENATED MODULE: ./src/prompt/deletion-impact.ts
+
+const DELETION_IMPACT_SYSTEM = `你是一个代码审查专家，专门分析删除代码可能带来的影响。
+
+## 任务
+分析以下被删除的代码块，判断删除这些代码是否会影响到其他功能。
+
+## 分析要点
+1. **功能依赖**: 被删除的代码是否被其他模块调用或依赖
+2. **接口变更**: 删除是否会导致 API 或接口不兼容
+3. **副作用**: 删除是否会影响系统的其他行为
+4. **数据流**: 删除是否会中断数据处理流程
+
+## 风险等级判断标准
+- **high**: 删除的代码被其他文件直接调用，删除后会导致编译错误或运行时异常
+- **medium**: 删除的代码可能影响某些功能的行为，但不会导致直接错误
+- **low**: 删除的代码影响较小，可能只是清理无用代码
+- **none**: 删除的代码确实是无用代码，不会产生任何影响
+
+## 输出要求
+- 对每个有风险的删除块给出详细分析
+- 如果删除是安全的，也要说明原因
+- 提供具体的建议`;
+function buildDeletedCodeSection(ctx) {
+    return ctx.deletedBlocks.map((block, index)=>{
+        const refs = ctx.references.get(`${block.file}:${block.startLine}-${block.endLine}`) || [];
+        return `### 删除块 ${index + 1}: ${block.file}:${block.startLine}-${block.endLine}\n\n\`\`\`\n${block.content}\n\`\`\`\n\n可能引用此代码的文件: ${refs.length > 0 ? refs.join(", ") : "未发现直接引用"}\n`;
+    }).join("\n");
+}
+const buildDeletionImpactPrompt = (ctx)=>{
+    validateArray(ctx.deletedBlocks, "deletedBlocks");
+    validateRequired(ctx.references, "references");
+    return {
+        systemPrompt: DELETION_IMPACT_SYSTEM,
+        userPrompt: `## 被删除的代码块\n\n${buildDeletedCodeSection(ctx)}\n请分析这些删除操作可能带来的影响。`
+    };
+};
+/** @deprecated 使用 buildDeletionImpactPrompt */ const buildDeletionImpactSystemPrompt = (ctx)=>buildDeletionImpactPrompt(ctx);
+/** @deprecated 使用 buildDeletionImpactPrompt */ const buildDeletionImpactUserPrompt = (ctx)=>buildDeletionImpactPrompt(ctx);
+const DELETION_IMPACT_AGENT_SYSTEM = `你是一个资深代码架构师，擅长分析代码变更的影响范围和潜在风险。
+
+## 任务
+深入分析以下被删除的代码块，评估删除操作对代码库的影响。
+
+## 你的能力
+你可以使用以下工具来深入分析代码：
+- **Read**: 读取文件内容，查看被删除代码的完整上下文
+- **Grep**: 搜索代码库，查找对被删除代码的引用
+- **Glob**: 查找匹配模式的文件
+
+## 分析流程
+1. 首先阅读被删除代码的上下文，理解其功能
+2. 使用 Grep 搜索代码库中对这些代码的引用
+3. 分析引用处的代码，判断删除后的影响
+4. 给出风险评估和建议
+
+## 风险等级判断标准
+- **high**: 删除的代码被其他文件直接调用，删除后会导致编译错误或运行时异常
+- **medium**: 删除的代码可能影响某些功能的行为，但不会导致直接错误
+- **low**: 删除的代码影响较小，可能只是清理无用代码
+- **none**: 删除的代码确实是无用代码，不会产生任何影响
+
+## 输出要求
+- 对每个有风险的删除块给出详细分析
+- 如果删除是安全的，也要说明原因
+- 提供具体的建议`;
+const buildDeletionImpactAgentPrompt = (ctx)=>{
+    validateArray(ctx.deletedBlocks, "deletedBlocks");
+    validateRequired(ctx.references, "references");
+    return {
+        systemPrompt: DELETION_IMPACT_AGENT_SYSTEM,
+        userPrompt: `## 被删除的代码块\n\n${buildDeletedCodeSection(ctx)}\n## 补充说明\n\n请使用你的工具能力深入分析这些删除操作可能带来的影响。\n- 如果需要查看更多上下文，请读取相关文件\n- 如果需要确认引用关系，请搜索代码库\n- 分析完成后，给出结构化的影响评估`
+    };
+};
+/** @deprecated 使用 buildDeletionImpactAgentPrompt */ const buildDeletionImpactAgentSystemPrompt = (ctx)=>buildDeletionImpactAgentPrompt(ctx);
+/** @deprecated 使用 buildDeletionImpactAgentPrompt */ const buildDeletionImpactAgentUserPrompt = (ctx)=>buildDeletionImpactAgentPrompt(ctx);
+
+;// CONCATENATED MODULE: ./src/prompt/issue-verify.ts
+
+/**
+ * 构建问题验证提示词
+ */ const buildIssueVerifyPrompt = (ctx)=>{
+    // 验证必需的输入参数
+    validateRequired(ctx.issue, "issue");
+    validateArray(ctx.fileContent, "fileContent");
+    const padWidth = String(ctx.fileContent.length).length;
+    const linesWithNumbers = ctx.fileContent.map(([, line], index)=>`${String(index + 1).padStart(padWidth)}| ${line}`).join("\n");
+    const systemPrompt = `你是一个代码审查专家。你的任务是判断之前发现的一个代码问题：
+1. 是否有效（是否真的违反了规则）
+2. 是否已经被修复
+
+请仔细分析当前的代码内容。
+
+## 输出要求
+- valid: 布尔值，true 表示问题有效（代码确实违反了规则），false 表示问题无效（误报）
+- fixed: 布尔值，true 表示问题已经被修复，false 表示问题仍然存在
+- reason: 判断依据
+
+## 判断标准
+
+### valid 判断
+- 根据规则 ID 和问题描述，判断代码是否真的违反了该规则
+- 如果问题描述与实际代码不符，valid 为 false
+- 如果规则不适用于该代码场景，valid 为 false
+
+### fixed 判断
+- 只有当问题所在的代码已被修改，且修改后的代码不再违反规则时，fixed 才为 true
+- 如果问题所在的代码仍然存在且仍违反规则，fixed 必须为 false
+- 如果代码行号发生变化但问题本质仍存在，fixed 必须为 false
+
+## 重要提醒
+- valid=false 时，fixed 的值无意义（无效问题无需修复）
+- 请确保 valid 和 fixed 的值与 reason 的描述一致！`;
+    // 构建规则定义部分
+    let ruleSection = "";
+    if (ctx.specsSection) {
+        ruleSection = ctx.specsSection;
+    } else if (ctx.ruleInfo) {
+        const { spec, rule } = ctx.ruleInfo;
+        ruleSection = `### ${spec.filename} (${spec.type})\n\n${spec.content.slice(0, 200)}...\n\n#### 规则\n- ${rule.id}: ${rule.title}\n  ${rule.description}`;
+    }
+    const userPrompt = `## 规则定义
+
+${ruleSection}
+
+## 之前发现的问题
+
+- **文件**: ${ctx.issue.file}
+- **行号**: ${ctx.issue.line}
+- **规则**: ${ctx.issue.ruleId} (来自 ${ctx.issue.specFile})
+- **问题描述**: ${ctx.issue.reason}
+${ctx.issue.suggestion ? `- **原建议**: ${ctx.issue.suggestion}` : ""}
+
+## 当前文件内容
+
+\`\`\`
+${linesWithNumbers}
+\`\`\`
+
+请判断这个问题是否有效，以及是否已经被修复。`;
+    return {
+        systemPrompt,
+        userPrompt
+    };
+};
+
+;// CONCATENATED MODULE: ./src/prompt/index.ts
+// 统一导出所有提示词
+// 类型定义
+// JSON Schemas
+
+// 代码审查提示词
+
+// PR 描述生成提示词
+
+// 删除影响分析提示词
+
+// 问题验证提示词
+
+
+;// CONCATENATED MODULE: ./src/system-rules/max-lines-per-file.ts
+
+const RULE_ID = "system:max-lines-per-file";
+const SPEC_FILE = "__system__";
+function checkMaxLinesPerFile(changedFiles, fileContents, rule, round, verbose) {
+    const [maxLine, severity] = rule;
+    const staticIssues = [];
+    const skippedFiles = new Set();
+    if (maxLine <= 0) {
+        return {
+            staticIssues,
+            skippedFiles
+        };
+    }
+    for (const file of changedFiles){
+        if (file.status === "deleted" || !file.filename) continue;
+        const filename = file.filename;
+        const contentLines = fileContents.get(filename);
+        if (!contentLines || contentLines.length <= maxLine) continue;
+        if (shouldLog(verbose, 1)) {
+            console.log(`⚠️  [system-rules/maxLinesPerFile] ${filename}: ${contentLines.length} 行超过限制 ${maxLine} 行，跳过 LLM 审查`);
+        }
+        skippedFiles.add(filename);
+        staticIssues.push({
+            file: filename,
+            line: "1",
+            code: "",
+            ruleId: RULE_ID,
+            specFile: SPEC_FILE,
+            reason: `文件共 ${contentLines.length} 行，超过静态规则限制 ${maxLine} 行，已跳过 LLM 审查。请考虑拆分文件或调大 staticRules.maxLinesPerFile 配置。`,
+            severity,
+            round,
+            date: new Date().toISOString()
+        });
+    }
+    return {
+        staticIssues,
+        skippedFiles
+    };
+}
+
+;// CONCATENATED MODULE: ./src/system-rules/index.ts
+
+
+/**
+ * 对变更文件执行所有已启用的静态规则检查。
+ * 返回系统问题列表和需要跳过 LLM 审查的文件集合。
+ */ function applyStaticRules(changedFiles, fileContents, staticRules, round, verbose) {
+    const staticIssues = [];
+    const skippedFiles = new Set();
+    if (!staticRules) {
+        return {
+            staticIssues,
+            skippedFiles
+        };
+    }
+    if (staticRules.maxLinesPerFile) {
+        const result = checkMaxLinesPerFile(changedFiles, fileContents, staticRules.maxLinesPerFile, round, verbose);
+        staticIssues.push(...result.staticIssues);
+        result.skippedFiles.forEach((f)=>skippedFiles.add(f));
+    }
+    return {
+        staticIssues,
+        skippedFiles
+    };
+}
+
+;// CONCATENATED MODULE: ./src/review-llm.ts
+
+
+
+
+
+
+
+
 class ReviewLlmProcessor {
     llmProxyService;
     reviewSpecService;
@@ -3924,8 +4689,11 @@ class ReviewLlmProcessor {
                 return false;
             }
             // 如果有 includes 配置，检查文件名是否匹配 includes 模式
+            // 需先提取纯 glob（去掉 added|/modified| 前缀，过滤 code-* 空串），避免 micromatch 报错
             if (spec.includes.length > 0) {
-                return micromatch_0.isMatch(filename, spec.includes, {
+                const globs = extractGlobsFromIncludes(spec.includes);
+                if (globs.length === 0) return true;
+                return micromatch_0.isMatch(filename, globs, {
                     matchBase: true
                 });
             }
@@ -3933,57 +4701,52 @@ class ReviewLlmProcessor {
             return true;
         });
     }
-    /**
-   * 构建 systemPrompt
-   */ buildSystemPrompt(specsSection) {
-        return `你是一个专业的代码审查专家，负责根据团队的编码规范对代码进行严格审查。
-
-## 审查规范
-
-${specsSection}
-
-## 审查要求
-
-1. **严格遵循规范**：只按照上述审查规范进行审查，不要添加规范之外的要求
-2. **精准定位问题**：每个问题必须指明具体的行号，行号从文件内容中的 "行号|" 格式获取
-3. **避免重复报告**：如果提示词中包含"上一次审查结果"，请不要重复报告已存在的问题
-4. **提供可行建议**：对于每个问题，提供具体的修改建议代码
-
-## 注意事项
-
-- 变更文件内容已在上下文中提供，无需调用读取工具
-- 你可以读取项目中的其他文件以了解上下文
-- 不要调用编辑工具修改文件，你的职责是审查而非修改
-- 文件内容格式为 "CommitHash 行号| 代码"，输出的 line 字段应对应原始行号
-
-## 输出要求
-
-- 发现问题时：在 issues 数组中列出所有问题，每个问题包含 file、line、ruleId、specFile、reason、suggestion、severity
-- 无论是否发现问题：都必须在 summary 中提供该文件的审查总结，简要说明审查结果`;
-    }
-    async buildReviewPrompt(specs, changedFiles, fileContents, commits, existingResult) {
+    async buildReviewPrompt(specs, changedFiles, fileContents, commits, existingResult, whenModifiedCode, verbose, systemRules) {
+        const round = (existingResult?.round ?? 0) + 1;
+        const { staticIssues, skippedFiles } = applyStaticRules(changedFiles, fileContents, systemRules, round, verbose);
         const fileDataList = changedFiles.filter((f)=>f.status !== "deleted" && f.filename).map((file)=>{
             const filename = file.filename;
+            if (skippedFiles.has(filename)) return null;
             const contentLines = fileContents.get(filename);
             if (!contentLines) {
                 return {
                     filename,
                     file,
-                    linesWithNumbers: "(无法获取内容)",
+                    contentLines: null,
                     commitsSection: "- 无相关 commits"
                 };
             }
-            const linesWithNumbers = buildLinesWithNumbers(contentLines);
             const commitsSection = buildCommitsSection(contentLines, commits);
             return {
                 filename,
                 file,
-                linesWithNumbers,
+                contentLines,
                 commitsSection
             };
         });
-        const filePrompts = await Promise.all(fileDataList.map(async ({ filename, file, linesWithNumbers, commitsSection })=>{
+        const filePrompts = await Promise.all(fileDataList.filter((item)=>item !== null).map(async ({ filename, file, contentLines, commitsSection })=>{
             const fileDirectoryInfo = await this.getFileDirectoryInfo(filename);
+            // 根据文件过滤 specs，只注入与当前文件匹配的规则
+            const fileSpecs = this.filterSpecsForFile(specs, filename);
+            // 从全局 whenModifiedCode 配置中解析代码结构过滤类型
+            const codeBlockTypes = whenModifiedCode ? extractCodeBlockTypes(whenModifiedCode) : [];
+            // 构建带行号的内容：有 code-* 过滤时只输出匹配的代码块范围
+            let linesWithNumbers;
+            if (!contentLines) {
+                linesWithNumbers = "(无法获取内容)";
+            } else if (codeBlockTypes.length > 0) {
+                const visibleRanges = extractCodeBlocks(contentLines, codeBlockTypes);
+                // 如果配置了 whenModifiedCode 但没有匹配的代码块，跳过这个文件
+                if (visibleRanges.length === 0) {
+                    if (shouldLog(verbose, 2)) {
+                        console.log(`[buildReviewPrompt] ${filename}: 没有匹配的 ${codeBlockTypes.join(", ")} 代码块，跳过审查`);
+                    }
+                    return null;
+                }
+                linesWithNumbers = buildLinesWithNumbers(contentLines, visibleRanges);
+            } else {
+                linesWithNumbers = buildLinesWithNumbers(contentLines);
+            }
             // 获取该文件上一次的审查结果
             const existingFileSummary = existingResult?.summary?.find((s)=>s.file === filename);
             const existingFileIssues = existingResult?.issues?.filter((i)=>i.file === filename) ?? [];
@@ -4005,37 +4768,27 @@ ${specsSection}
                 }
                 previousReviewSection = parts.join("\n");
             }
-            const userPrompt = `## ${filename} (${file.status})
-
-### 文件内容
-
-\`\`\`
-${linesWithNumbers}
-\`\`\`
-
-### 该文件的相关 Commits
-
-${commitsSection}
-
-### 该文件所在的目录树
-
-${fileDirectoryInfo}
-
-### 上一次审查结果
-
-${previousReviewSection}`;
-            // 根据文件过滤 specs，只注入与当前文件匹配的规则
-            const fileSpecs = this.filterSpecsForFile(specs, filename);
             const specsSection = this.reviewSpecService.buildSpecsSection(fileSpecs);
-            const systemPrompt = this.buildSystemPrompt(specsSection);
+            const { systemPrompt, userPrompt } = buildFileReviewPrompt({
+                filename,
+                status: file.status,
+                linesWithNumbers,
+                commitsSection,
+                fileDirectoryInfo,
+                previousReviewSection,
+                specsSection
+            });
             return {
                 filename,
                 systemPrompt,
                 userPrompt
             };
         }));
+        // 过滤掉 null 值（跳过的文件）
+        const validFilePrompts = filePrompts.filter((fp)=>fp !== null);
         return {
-            filePrompts
+            filePrompts: validFilePrompts,
+            staticIssues: staticIssues.length > 0 ? staticIssues : undefined
         };
     }
     async runLLMReview(llmMode, reviewPrompt, options = {}) {
@@ -4230,50 +4983,16 @@ ${previousReviewSection}`;
    * 使用 AI 根据 commits、变更文件和代码内容总结 PR 实现的功能
    * @returns 包含 title 和 description 的对象
    */ async generatePrDescription(commits, changedFiles, llmMode, fileContents, verbose) {
-        const commitMessages = commits.map((c)=>`- ${c.sha?.slice(0, 7)}: ${c.commit?.message?.split("\n")[0]}`).join("\n");
-        const fileChanges = changedFiles.slice(0, 30).map((f)=>`- ${f.filename} (${f.status})`).join("\n");
-        // 构建代码变更内容（只包含变更行，限制总长度）
-        let codeChangesSection = "";
-        if (fileContents && fileContents.size > 0) {
-            const codeSnippets = [];
-            let totalLength = 0;
-            const maxTotalLength = 8000; // 限制代码总长度
-            for (const [filename, lines] of fileContents){
-                if (totalLength >= maxTotalLength) break;
-                // 只提取有变更的行（commitHash 不是 "-------"）
-                const changedLines = lines.map(([hash, code], idx)=>hash !== "-------" ? `${idx + 1}: ${code}` : null).filter(Boolean);
-                if (changedLines.length > 0) {
-                    const snippet = `### ${filename}\n\`\`\`\n${changedLines.slice(0, 50).join("\n")}\n\`\`\``;
-                    if (totalLength + snippet.length <= maxTotalLength) {
-                        codeSnippets.push(snippet);
-                        totalLength += snippet.length;
-                    }
-                }
-            }
-            if (codeSnippets.length > 0) {
-                codeChangesSection = `\n\n## 代码变更内容\n${codeSnippets.join("\n\n")}`;
-            }
-        }
-        const prompt = `请根据以下 PR 的 commit 记录、文件变更和代码内容，用简洁的中文总结这个 PR 实现了什么功能。
-要求：
-1. 第一行输出 PR 标题，格式必须是: Feat xxx 或 Fix xxx 或 Refactor xxx（根据变更类型选择，整体不超过 50 个字符）
-2. 空一行后输出详细描述
-3. 描述应该简明扼要，突出核心功能点
-4. 使用 Markdown 格式
-5. 不要逐条列出 commit，而是归纳总结
-6. 重点分析代码变更的实际功能
-
-## Commit 记录 (${commits.length} 个)
-${commitMessages || "无"}
-
-## 文件变更 (${changedFiles.length} 个文件)
-${fileChanges || "无"}
-${changedFiles.length > 30 ? `\n... 等 ${changedFiles.length - 30} 个文件` : ""}${codeChangesSection}`;
+        const { userPrompt } = buildPrDescriptionPrompt({
+            commits,
+            changedFiles,
+            fileContents
+        });
         try {
             const stream = this.llmProxyService.chatStream([
                 {
                     role: "user",
-                    content: prompt
+                    content: userPrompt
                 }
             ], {
                 adapter: llmMode
@@ -4304,25 +5023,15 @@ ${changedFiles.length > 30 ? `\n... 等 ${changedFiles.length - 30} 个文件` :
     /**
    * 使用 LLM 生成 PR 标题
    */ async generatePrTitle(commits, changedFiles) {
-        const commitMessages = commits.slice(0, 10).map((c)=>c.commit?.message?.split("\n")[0]).filter(Boolean).join("\n");
-        const fileChanges = changedFiles.slice(0, 20).map((f)=>`${f.filename} (${f.status})`).join("\n");
-        const prompt = `请根据以下 commit 记录和文件变更，生成一个简短的 PR 标题。
-要求：
-1. 格式必须是: Feat: xxx 或 Fix: xxx 或 Refactor: xxx
-2. 根据变更内容选择合适的前缀（新功能用 Feat，修复用 Fix，重构用 Refactor）
-3. xxx 部分用简短的中文描述（整体不超过 50 个字符）
-4. 只输出标题，不要加任何解释
-
-Commit 记录:
-${commitMessages || "无"}
-
-文件变更:
-${fileChanges || "无"}`;
+        const { userPrompt } = buildPrTitlePrompt({
+            commits,
+            changedFiles
+        });
         try {
             const stream = this.llmProxyService.chatStream([
                 {
                     role: "user",
-                    content: prompt
+                    content: userPrompt
                 }
             ], {
                 adapter: "openai"
@@ -4386,6 +5095,7 @@ ${fileChanges || "无"}`;
 
 
 
+
 class ReviewService {
     gitProvider;
     config;
@@ -4448,9 +5158,17 @@ class ReviewService {
         const source = await this.resolveSourceData(context);
         if (source.earlyReturn) return source.earlyReturn;
         const { prModel, commits, changedFiles, headSha, isDirectFileMode } = source;
+        const effectiveWhenModifiedCode = isDirectFileMode ? undefined : context.whenModifiedCode;
+        if (isDirectFileMode && context.whenModifiedCode?.length && shouldLog(verbose, 1)) {
+            console.log(`ℹ️  直接文件模式下忽略 whenModifiedCode 过滤`);
+        }
         // 2. 规则匹配
         const specs = await this.issueFilter.loadSpecs(specSources, verbose);
         const applicableSpecs = this.reviewSpecService.filterApplicableSpecs(specs, changedFiles);
+        if (shouldLog(verbose, 2)) {
+            console.log(`[execute] loadSpecs: loaded ${specs.length} specs from sources: ${JSON.stringify(specSources)}`);
+            console.log(`[execute] filterApplicableSpecs: ${applicableSpecs.length} applicable out of ${specs.length}, changedFiles=${JSON.stringify(changedFiles.map((f)=>f.filename))}`);
+        }
         if (shouldLog(verbose, 1)) {
             console.log(`   适用的规则文件: ${applicableSpecs.length}`);
         }
@@ -4471,7 +5189,7 @@ class ReviewService {
         if (shouldLog(verbose, 1)) {
             console.log(`🔄 当前审查轮次: ${(existingResultModel?.round ?? 0) + 1}`);
         }
-        const reviewPrompt = await this.buildReviewPrompt(specs, changedFiles, fileContents, commits, existingResultModel?.result ?? null);
+        const reviewPrompt = await this.buildReviewPrompt(specs, changedFiles, fileContents, commits, existingResultModel?.result ?? null, effectiveWhenModifiedCode, verbose, context.systemRules);
         const result = await this.runLLMReview(llmMode, reviewPrompt, {
             verbose,
             concurrency: context.concurrency,
@@ -4495,6 +5213,16 @@ class ReviewService {
             isDirectFileMode,
             context
         });
+        // 静态规则产生的系统问题直接合并，不经过过滤管道
+        if (reviewPrompt.staticIssues?.length) {
+            result.issues = [
+                ...reviewPrompt.staticIssues,
+                ...result.issues
+            ];
+            if (shouldLog(verbose, 1)) {
+                console.log(`⚙️  追加 ${reviewPrompt.staticIssues.length} 个静态规则系统问题`);
+            }
+        }
         if (shouldLog(verbose, 1)) {
             console.log(`📝 最终发现 ${result.issues.length} 个问题`);
         }
@@ -4516,8 +5244,8 @@ class ReviewService {
    * 包含前置过滤（merge commit、files、commits、includes）。
    * 如果需要提前返回（如同分支、重复 workflow），通过 earlyReturn 字段传递。
    */ async resolveSourceData(context) {
-        const { owner, repo, prNumber, baseRef, headRef, verbose, ci, includes, files, commits: filterCommits, localMode, skipDuplicateWorkflow } = context;
-        const isDirectFileMode = !!(files && files.length > 0 && baseRef === headRef);
+        const { owner, repo, prNumber, baseRef, headRef, verbose, ci, includes, files, commits: filterCommits, localMode, duplicateWorkflowResolved } = context;
+        const isDirectFileMode = !!(files && files.length > 0 && !prNumber);
         let isLocalMode = !!localMode;
         let effectiveBaseRef = baseRef;
         let effectiveHeadRef = headRef;
@@ -4576,8 +5304,17 @@ class ReviewService {
                 }
             }
         }
-        // PR 模式、分支比较模式、或本地模式回退后的分支比较
-        if (prNumber) {
+        // 直接文件审查模式（-f）：绕过 diff，直接按指定文件构造审查输入
+        if (isDirectFileMode) {
+            if (shouldLog(verbose, 1)) {
+                console.log(`📥 直接审查指定文件模式 (${files.length} 个文件)`);
+            }
+            changedFiles = files.map((f)=>({
+                    filename: f,
+                    status: "modified"
+                }));
+            isLocalMode = true;
+        } else if (prNumber) {
             if (shouldLog(verbose, 1)) {
                 console.log(`📥 获取 PR #${prNumber} 信息 (owner: ${owner}, repo: ${repo})`);
             }
@@ -4591,9 +5328,9 @@ class ReviewService {
                 console.log(`   Changed files: ${changedFiles.length}`);
             }
             // 检查是否有其他同名 review workflow 正在运行中
-            if (skipDuplicateWorkflow && ci && prInfo?.head?.sha) {
-                const skipResult = await this.checkDuplicateWorkflow(prModel, prInfo.head.sha, verbose);
-                if (skipResult) {
+            if (duplicateWorkflowResolved !== "off" && ci && prInfo?.head?.sha) {
+                const duplicateResult = await this.checkDuplicateWorkflow(prModel, prInfo.head.sha, duplicateWorkflowResolved, verbose);
+                if (duplicateResult) {
                     return {
                         prModel,
                         commits,
@@ -4601,20 +5338,12 @@ class ReviewService {
                         headSha: prInfo.head.sha,
                         isLocalMode,
                         isDirectFileMode,
-                        earlyReturn: skipResult
+                        earlyReturn: duplicateResult
                     };
                 }
             }
         } else if (effectiveBaseRef && effectiveHeadRef) {
-            if (files && files.length > 0 && effectiveBaseRef === effectiveHeadRef) {
-                if (shouldLog(verbose, 1)) {
-                    console.log(`📥 直接审查指定文件模式 (${files.length} 个文件)`);
-                }
-                changedFiles = files.map((f)=>({
-                        filename: f,
-                        status: "modified"
-                    }));
-            } else if (changedFiles.length === 0) {
+            if (changedFiles.length === 0) {
                 if (shouldLog(verbose, 1)) {
                     console.log(`📥 获取 ${effectiveBaseRef}...${effectiveHeadRef} 的差异 (owner: ${owner}, repo: ${repo})`);
                 }
@@ -4677,10 +5406,19 @@ class ReviewService {
         // 3. 使用 includes 过滤文件和 commits（支持 added|/modified|/deleted| 前缀语法）
         if (includes && includes.length > 0) {
             const beforeFiles = changedFiles.length;
+            if (shouldLog(verbose, 2)) {
+                console.log(`[resolveSourceData] filterFilesByIncludes: before=${JSON.stringify(changedFiles.map((f)=>({
+                        filename: f.filename,
+                        status: f.status
+                    })))}, includes=${JSON.stringify(includes)}`);
+            }
             changedFiles = filterFilesByIncludes(changedFiles, includes);
             if (shouldLog(verbose, 1)) {
                 console.log(`   Includes 过滤文件: ${beforeFiles} -> ${changedFiles.length} 个文件`);
             }
+            if (shouldLog(verbose, 2)) {
+                console.log(`[resolveSourceData] filterFilesByIncludes: after=${JSON.stringify(changedFiles.map((f)=>f.filename))}`);
+            }
             const globs = extractGlobsFromIncludes(includes);
             const beforeCommits = commits.length;
             const filteredCommits = [];
@@ -5012,7 +5750,8 @@ class ReviewService {
     }
     /**
    * 检查是否有其他同名 review workflow 正在运行中
-   */ async checkDuplicateWorkflow(prModel, headSha, verbose) {
+   * 根据 duplicateWorkflowResolved 配置决定是跳过还是删除旧评论
+   */ async checkDuplicateWorkflow(prModel, headSha, mode, verbose) {
         const ref = process.env.GITHUB_REF || process.env.GITEA_REF || "";
         const prMatch = ref.match(/refs\/pull\/(\d+)/);
         const currentPrNumber = prMatch ? parseInt(prMatch[1], 10) : prModel.number;
@@ -5024,6 +5763,16 @@ class ReviewService {
             const currentRunId = process.env.GITHUB_RUN_ID || process.env.GITEA_RUN_ID;
             const duplicateReviewRuns = runningWorkflows.filter((w)=>w.sha === headSha && w.name === currentWorkflowName && (!currentRunId || String(w.id) !== currentRunId));
             if (duplicateReviewRuns.length > 0) {
+                if (mode === "delete") {
+                    // 删除模式：清理旧的 AI Review 评论和 PR Review
+                    if (shouldLog(verbose, 1)) {
+                        console.log(`🗑️ 检测到 ${duplicateReviewRuns.length} 个同名 workflow，清理旧的 AI Review 评论...`);
+                    }
+                    await this.cleanupDuplicateAiReviews(prModel, verbose);
+                    // 清理后继续执行当前审查
+                    return null;
+                }
+                // 跳过模式（默认）
                 if (shouldLog(verbose, 1)) {
                     console.log(`⏭️ 跳过审查: 当前 PR #${currentPrNumber} 有 ${duplicateReviewRuns.length} 个同名 workflow 正在运行中`);
                 }
@@ -5042,6 +5791,50 @@ class ReviewService {
         }
         return null;
     }
+    /**
+   * 清理重复的 AI Review 评论（Issue Comments 和 PR Reviews）
+   */ async cleanupDuplicateAiReviews(prModel, verbose) {
+        try {
+            // 删除 Issue Comments（主评论）
+            const comments = await prModel.getComments();
+            const aiComments = comments.filter((c)=>c.body?.includes(REVIEW_COMMENT_MARKER));
+            let deletedComments = 0;
+            for (const comment of aiComments){
+                if (comment.id) {
+                    try {
+                        await prModel.deleteComment(comment.id);
+                        deletedComments++;
+                    } catch  {
+                    // 忽略删除失败
+                    }
+                }
+            }
+            if (deletedComments > 0 && shouldLog(verbose, 1)) {
+                console.log(`   已删除 ${deletedComments} 个重复的 AI Review 主评论`);
+            }
+            // 删除 PR Reviews（行级评论）
+            const reviews = await prModel.getReviews();
+            const aiReviews = reviews.filter((r)=>r.body?.includes(REVIEW_LINE_COMMENTS_MARKER));
+            let deletedReviews = 0;
+            for (const review of aiReviews){
+                if (review.id) {
+                    try {
+                        await prModel.deleteReview(review.id);
+                        deletedReviews++;
+                    } catch  {
+                    // 已提交的 review 无法删除，忽略
+                    }
+                }
+            }
+            if (deletedReviews > 0 && shouldLog(verbose, 1)) {
+                console.log(`   已删除 ${deletedReviews} 个重复的 AI Review PR Review`);
+            }
+        } catch (error) {
+            if (shouldLog(verbose, 1)) {
+                console.warn(`⚠️ 清理旧评论失败:`, error instanceof Error ? error.message : error);
+            }
+        }
+    }
     // --- Delegation methods for backward compatibility with tests ---
     async fillIssueAuthors(...args) {
         return this.contextBuilder.fillIssueAuthors(...args);
@@ -5114,31 +5907,9 @@ class ReviewService {
 
 ;// CONCATENATED MODULE: ./src/issue-verify.service.ts
 
+
 const TRUE = "true";
 const FALSE = "false";
-const VERIFY_SCHEMA = {
-    type: "object",
-    properties: {
-        fixed: {
-            type: "boolean",
-            description: "问题是否已被修复"
-        },
-        valid: {
-            type: "boolean",
-            description: "问题是否有效，有效的条件就是你需要看看代码是否符合规范"
-        },
-        reason: {
-            type: "string",
-            description: "判断依据，说明为什么认为问题已修复或仍存在"
-        }
-    },
-    required: [
-        "fixed",
-        "valid",
-        "reason"
-    ],
-    additionalProperties: false
-};
 class IssueVerifyService {
     llmProxyService;
     reviewSpecService;
@@ -5211,13 +5982,13 @@ class IssueVerifyService {
                 }
             }
         });
-        const results = await executor.map(toVerify, async ({ issue, fileContent, ruleInfo })=>this.verifySingleIssue(issue, fileContent, ruleInfo, llmMode, llmJsonPut, verbose), ({ issue })=>`${issue.file}:${issue.line}`);
+        const results = await executor.map(toVerify, async ({ issue, fileContent, ruleInfo })=>this.verifySingleIssue(issue, fileContent, ruleInfo, llmMode, llmJsonPut, verbose), ({ issue })=>`${issue.file}:${issue.line}:${issue.ruleId}`);
         for (const result of results){
             if (result.success && result.result) {
                 verifiedIssues.push(result.result);
             } else {
                 // 失败时保留原始 issue
-                const originalItem = toVerify.find((item)=>`${item.issue.file}:${item.issue.line}` === result.id);
+                const originalItem = toVerify.find((item)=>`${item.issue.file}:${item.issue.line}:${item.issue.ruleId}` === result.id);
                 if (originalItem) {
                     verifiedIssues.push(originalItem.issue);
                 }
@@ -5233,7 +6004,15 @@ class IssueVerifyService {
     /**
    * 验证单个 issue 是否已修复
    */ async verifySingleIssue(issue, fileContent, ruleInfo, llmMode, llmJsonPut, verbose) {
-        const verifyPrompt = this.buildVerifyPrompt(issue, fileContent, ruleInfo);
+        const specsSection = ruleInfo ? this.reviewSpecService.buildSpecsSection([
+            ruleInfo.spec
+        ]) : "";
+        const verifyPrompt = buildIssueVerifyPrompt({
+            issue,
+            fileContent,
+            ruleInfo,
+            specsSection
+        });
         try {
             const stream = this.llmProxyService.chatStream([
                 {
@@ -5294,66 +6073,18 @@ class IssueVerifyService {
         }
     }
     /**
+   * @deprecated 使用 prompt/issue-verify.ts 中的 buildIssueVerifyPrompt
    * 构建验证单个 issue 是否已修复的 prompt
    */ buildVerifyPrompt(issue, fileContent, ruleInfo) {
-        const padWidth = String(fileContent.length).length;
-        const linesWithNumbers = fileContent.map(([, line], index)=>`${String(index + 1).padStart(padWidth)}| ${line}`).join("\n");
-        const systemPrompt = `你是一个代码审查专家。你的任务是判断之前发现的一个代码问题：
-1. 是否有效（是否真的违反了规则）
-2. 是否已经被修复
-
-请仔细分析当前的代码内容。
-
-## 输出要求
-- valid: 布尔值，true 表示问题有效（代码确实违反了规则），false 表示问题无效（误报）
-- fixed: 布尔值，true 表示问题已经被修复，false 表示问题仍然存在
-- reason: 判断依据
-
-## 判断标准
-
-### valid 判断
-- 根据规则 ID 和问题描述，判断代码是否真的违反了该规则
-- 如果问题描述与实际代码不符，valid 为 false
-- 如果规则不适用于该代码场景，valid 为 false
-
-### fixed 判断
-- 只有当问题所在的代码已被修改，且修改后的代码不再违反规则时，fixed 才为 true
-- 如果问题所在的代码仍然存在且仍违反规则，fixed 必须为 false
-- 如果代码行号发生变化但问题本质仍存在，fixed 必须为 false
-
-## 重要提醒
-- valid=false 时，fixed 的值无意义（无效问题无需修复）
-- 请确保 valid 和 fixed 的值与 reason 的描述一致！`;
-        // 构建规则定义部分
-        let ruleSection = "";
-        if (ruleInfo) {
-            ruleSection = this.reviewSpecService.buildSpecsSection([
-                ruleInfo.spec
-            ]);
-        }
-        const userPrompt = `## 规则定义
-
-${ruleSection}
-
-## 之前发现的问题
-
-- **文件**: ${issue.file}
-- **行号**: ${issue.line}
-- **规则**: ${issue.ruleId} (来自 ${issue.specFile})
-- **问题描述**: ${issue.reason}
-${issue.suggestion ? `- **原建议**: ${issue.suggestion}` : ""}
-
-## 当前文件内容
-
-\`\`\`
-${linesWithNumbers}
-\`\`\`
-
-请判断这个问题是否有效，以及是否已经被修复。`;
-        return {
-            systemPrompt,
-            userPrompt
-        };
+        const specsSection = ruleInfo ? this.reviewSpecService.buildSpecsSection([
+            ruleInfo.spec
+        ]) : "";
+        return buildIssueVerifyPrompt({
+            issue,
+            fileContent,
+            ruleInfo,
+            specsSection
+        });
     }
 }
 
@@ -5362,69 +6093,7 @@ ${linesWithNumbers}
 
 
 
-const DELETION_IMPACT_SCHEMA = {
-    type: "object",
-    properties: {
-        impacts: {
-            type: "array",
-            items: {
-                type: "object",
-                properties: {
-                    file: {
-                        type: "string",
-                        description: "被删除代码所在的文件路径"
-                    },
-                    deletedCode: {
-                        type: "string",
-                        description: "被删除的代码片段摘要（前50字符）"
-                    },
-                    riskLevel: {
-                        type: "string",
-                        enum: [
-                            "high",
-                            "medium",
-                            "low",
-                            "none"
-                        ],
-                        description: "风险等级：high=可能导致功能异常，medium=可能影响部分功能，low=影响较小，none=无影响"
-                    },
-                    affectedFiles: {
-                        type: "array",
-                        items: {
-                            type: "string"
-                        },
-                        description: "可能受影响的文件列表"
-                    },
-                    reason: {
-                        type: "string",
-                        description: "影响分析的详细说明"
-                    },
-                    suggestion: {
-                        type: "string",
-                        description: "建议的处理方式"
-                    }
-                },
-                required: [
-                    "file",
-                    "deletedCode",
-                    "riskLevel",
-                    "affectedFiles",
-                    "reason"
-                ],
-                additionalProperties: false
-            }
-        },
-        summary: {
-            type: "string",
-            description: "删除代码影响的整体总结"
-        }
-    },
-    required: [
-        "impacts",
-        "summary"
-    ],
-    additionalProperties: false
-};
+
 class DeletionImpactService {
     llmProxyService;
     gitProvider;
@@ -5853,43 +6522,10 @@ class DeletionImpactService {
    * 使用 LLM 分析删除代码的影响
    */ async analyzeWithLLM(deletedBlocks, references, llmMode, verbose) {
         const llmJsonPut = new LlmJsonPut(DELETION_IMPACT_SCHEMA);
-        const systemPrompt = `你是一个代码审查专家，专门分析删除代码可能带来的影响。
-
-## 任务
-分析以下被删除的代码块，判断删除这些代码是否会影响到其他功能。
-
-## 分析要点
-1. **功能依赖**: 被删除的代码是否被其他模块调用或依赖
-2. **接口变更**: 删除是否会导致 API 或接口不兼容
-3. **副作用**: 删除是否会影响系统的其他行为
-4. **数据流**: 删除是否会中断数据处理流程
-
-## 风险等级判断标准
-- **high**: 删除的代码被其他文件直接调用，删除后会导致编译错误或运行时异常
-- **medium**: 删除的代码可能影响某些功能的行为，但不会导致直接错误
-- **low**: 删除的代码影响较小，可能只是清理无用代码
-- **none**: 删除的代码确实是无用代码，不会产生任何影响
-
-## 输出要求
-- 对每个有风险的删除块给出详细分析
-- 如果删除是安全的，也要说明原因
-- 提供具体的建议`;
-        const deletedCodeSection = deletedBlocks.map((block, index)=>{
-            const refs = references.get(`${block.file}:${block.startLine}-${block.endLine}`) || [];
-            return `### 删除块 ${index + 1}: ${block.file}:${block.startLine}-${block.endLine}
-
-\`\`\`
-${block.content}
-\`\`\`
-
-可能引用此代码的文件: ${refs.length > 0 ? refs.join(", ") : "未发现直接引用"}
-`;
-        }).join("\n");
-        const userPrompt = `## 被删除的代码块
-
-${deletedCodeSection}
-
-请分析这些删除操作可能带来的影响。`;
+        const { systemPrompt, userPrompt } = buildDeletionImpactPrompt({
+            deletedBlocks,
+            references
+        });
         if (shouldLog(verbose, 2)) {
             console.log(`\nsystemPrompt:\n----------------\n${systemPrompt}\n----------------`);
             console.log(`\nuserPrompt:\n----------------\n${userPrompt}\n----------------`);
@@ -5945,54 +6581,10 @@ ${deletedCodeSection}
    * Claude Agent 可以使用工具主动探索代码库，分析更深入
    */ async analyzeWithAgent(analysisMode, deletedBlocks, references, verbose) {
         const llmJsonPut = new LlmJsonPut(DELETION_IMPACT_SCHEMA);
-        const systemPrompt = `你是一个资深代码架构师，擅长分析代码变更的影响范围和潜在风险。
-
-## 任务
-深入分析以下被删除的代码块，评估删除操作对代码库的影响。
-
-## 你的能力
-你可以使用以下工具来深入分析代码：
-- **Read**: 读取文件内容，查看被删除代码的完整上下文
-- **Grep**: 搜索代码库，查找对被删除代码的引用
-- **Glob**: 查找匹配模式的文件
-
-## 分析流程
-1. 首先阅读被删除代码的上下文，理解其功能
-2. 使用 Grep 搜索代码库中对这些代码的引用
-3. 分析引用处的代码，判断删除后的影响
-4. 给出风险评估和建议
-
-## 风险等级判断标准
-- **high**: 删除的代码被其他文件直接调用，删除后会导致编译错误或运行时异常
-- **medium**: 删除的代码可能影响某些功能的行为，但不会导致直接错误
-- **low**: 删除的代码影响较小，可能只是清理无用代码
-- **none**: 删除的代码确实是无用代码，不会产生任何影响
-
-## 输出要求
-- 对每个有风险的删除块给出详细分析
-- 如果删除是安全的，也要说明原因
-- 提供具体的建议`;
-        const deletedCodeSection = deletedBlocks.map((block, index)=>{
-            const refs = references.get(`${block.file}:${block.startLine}-${block.endLine}`) || [];
-            return `### 删除块 ${index + 1}: ${block.file}:${block.startLine}-${block.endLine}
-
-\`\`\`
-${block.content}
-\`\`\`
-
-可能引用此代码的文件: ${refs.length > 0 ? refs.join(", ") : "未发现直接引用"}
-`;
-        }).join("\n");
-        const userPrompt = `## 被删除的代码块
-
-${deletedCodeSection}
-
-## 补充说明
-
-请使用你的工具能力深入分析这些删除操作可能带来的影响。
-- 如果需要查看更多上下文，请读取相关文件
-- 如果需要确认引用关系，请搜索代码库
-- 分析完成后，给出结构化的影响评估`;
+        const { systemPrompt, userPrompt } = buildDeletionImpactAgentPrompt({
+            deletedBlocks,
+            references
+        });
         if (shouldLog(verbose, 2)) {
             console.log(`\n[Agent Mode] systemPrompt:\n----------------\n${systemPrompt}\n----------------`);
             console.log(`\n[Agent Mode] userPrompt:\n----------------\n${userPrompt}\n----------------`);
@@ -6169,6 +6761,7 @@ ${deletedCodeSection}
 
 
 
+
 /** MCP 工具输入 schema */ const listRulesInputSchema = z.object({});
 const getRulesForFileInputSchema = z.object({
     filePath: z.string().describe(t("review:mcp.dto.filePath")),
@@ -6275,7 +6868,9 @@ const tools = [
             const rules = applicableSpecs.flatMap((spec)=>spec.rules.filter((rule)=>{
                     const includes = rule.includes || spec.includes;
                     if (includes.length === 0) return true;
-                    return micromatch.isMatch(filePath, includes, {
+                    const globs = extractGlobsFromIncludes(includes);
+                    if (globs.length === 0) return true;
+                    return micromatch.isMatch(filePath, globs, {
                         matchBase: true
                     });
                 }).map((rule)=>({