@aipanel/core 1.3.4 → 1.3.5

package/lib/node/diagnostics.cjs

@@ -28,16 +28,13 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var diagnostics_exports = {};
 __export(diagnostics_exports, {
   DIAGNOSTICS_TOOL_DESCRIPTION: () => DIAGNOSTICS_TOOL_DESCRIPTION,
+  collectDiagnostics: () => collectDiagnostics,
   findAllTsconfigDirs: () => findAllTsconfigDirs,
   findTsconfigDir: () => findTsconfigDir,
-  formatDiagnosticsSections: () => formatDiagnosticsSections,
   isJsFile: () => isJsFile,
-  lintFiles: () => lintFiles,
-  lintSectionTitle: () => lintSectionTitle,
   omittedFindingsHint: () => omittedFindingsHint,
-  runAllChecks: () => runAllChecks,
-  runAllChecksForFiles: () => runAllChecksForFiles,
-  runProjectDiagnostics: () => runProjectDiagnostics,
+  renderDiagnostics: () => renderDiagnostics,
+  runDiagnostics: () => runDiagnostics,
   runTypeCheck: () => runTypeCheck,
   runTypeChecksForFiles: () => runTypeChecksForFiles,
   tscSectionTitle: () => tscSectionTitle
@@ -45,31 +42,23 @@ __export(diagnostics_exports, {
 module.exports = __toCommonJS(diagnostics_exports);
 var import_node_fs = __toESM(require("node:fs"));
 var import_node_path = __toESM(require("node:path"));
+var import_node_url = require("node:url");
 var import_execa = require("execa");
 var import_node_module = require("node:module");
 var import_constants = require("../common/constants.cjs");
+var import_diagnostics = require("../common/diagnostics.cjs");
 var import_node_logger = require("./node-logger.cjs");
 const import_meta = {};
 const log = (0, import_node_logger.createLogger)("Diagnostics");
-const JS_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".js",
-  ".jsx",
-  ".ts",
-  ".tsx",
-  ".mjs",
-  ".cjs",
-  ".mts",
-  ".cts",
-  ".vue"
-]);
+const JS_EXTENSIONS = new Set(import_diagnostics.SOURCE_EXTENSIONS);
 function isJsFile(filePath) {
   return JS_EXTENSIONS.has(import_node_path.default.extname(filePath));
 }
 const DIAGNOSTICS_TOOL_DESCRIPTION = [
-  "\u8FD0\u884C Lint\uFF08ESLint / oxlint\uFF09\u4E0E TypeScript \u7C7B\u578B\u8BCA\u65AD\uFF0C\u8FD4\u56DE\u8BCA\u65AD\u7ED3\u679C\u3002",
+  "\u8FD0\u884C\u9879\u76EE\u914D\u7F6E\u7684\u4EE3\u7801\u68C0\u67E5\uFF08\u9ED8\u8BA4 Lint \u4E0E TypeScript \u7C7B\u578B\u8BCA\u65AD\uFF09\uFF0C\u8FD4\u56DE\u8BCA\u65AD\u7ED3\u679C\u3002",
   "",
   "**\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B**\uFF1A",
-  `- Lint\uFF1AJavaScript / TypeScript / Vue \u6E90\u7801\uFF08${[...JS_EXTENSIONS].map((e) => `*${e}`).join(" ")}\uFF09\uFF1B\u4E24\u5F15\u64CE\u5747\u5B89\u88C5\u65F6\u5E76\u884C\u4E92\u8865\u8FD0\u884C\uFF08\u8BCA\u65AD\u6309\u6765\u6E90\u6807\u6CE8\uFF09`,
+  `- Lint\uFF1AJavaScript / TypeScript / Vue \u6E90\u7801\uFF08${[...JS_EXTENSIONS].map((e) => `*${e}`).join(" ")}\uFF09\uFF1B\u9879\u76EE\u540C\u65F6\u88C5\u6709 ESLint \u4E0E oxlint \u65F6\u4E92\u8865\u8FD0\u884C\uFF08\u8BCA\u65AD\u6309\u6765\u6E90\u6807\u6CE8\uFF09`,
   "- TypeScript \u7C7B\u578B\u68C0\u67E5\uFF1A*.ts *.tsx *.vue",
   "",
   "**\u4F55\u65F6\u4F7F\u7528\u6B64\u5DE5\u5177**\uFF1A",
@@ -99,53 +88,14 @@ function resolvePackageBin(basePkgJson, pkgName, binName) {
     }
   });
 }
-const _eslintClassByBase = /* @__PURE__ */ new Map();
-function loadESLint(workspace) {
-  const basePkgJson = import_node_path.default.join(workspace, "package.json");
-  return cachedResolve(_eslintClassByBase, basePkgJson, () => {
-    log.debug("Loading eslint", { workspace });
-    try {
-      const req = (0, import_node_module.createRequire)(basePkgJson);
-      const eslintModule = req("eslint");
-      const eslintClass = eslintModule.ESLint ?? eslintModule.FlatESLint ?? null;
-      log.debug("eslint loaded", { hasClass: !!eslintClass });
-      return eslintClass;
-    } catch (e) {
-      log.warn("eslint not found", { error: e.message });
-      return null;
-    }
-  });
-}
-async function lintFiles(pattern, cwd, warnLimit = 5) {
-  const eslintClass = loadESLint(cwd);
-  const [eslintOutput, oxlintOutput] = await Promise.all([
-    eslintClass ? runEslintFiles(eslintClass, pattern, cwd, warnLimit) : Promise.resolve(null),
-    runOxlintFiles(pattern, cwd, warnLimit)
-  ]);
-  const engines = [];
-  const texts = [];
-  const diagnostics = [];
-  for (const output of [eslintOutput, oxlintOutput]) {
-    if (!output) continue;
-    engines.push(...output.engines ?? []);
-    if (output.text) texts.push(output.text);
-    diagnostics.push(...output.diagnostics ?? []);
-  }
-  if (engines.length === 0) {
-    return {
-      text: `[Lint] \u672A\u8FD0\u884C\uFF1A\u65E0\u6CD5\u5728 workspace "${cwd}" \u89E3\u6790\u5230 eslint \u6216 oxlint`,
-      diagnostics: []
-    };
-  }
-  return { text: texts.join("\n\n") || void 0, diagnostics, engines };
-}
-function formatLintMessages(messages, engine, warnLimit) {
-  if (messages.length === 0) return { engines: [engine.label] };
+function formatLintMessages(messages, engine, warnLimit, minSeverity = "warning") {
   const ESLINT_ERROR = 2;
   const ESLINT_WARN = 1;
+  const kept = minSeverity === "error" ? messages.filter((m) => m.severity === ESLINT_ERROR) : messages;
+  if (kept.length === 0) return {};
   const lines = [];
-  const errors = messages.filter((m) => m.severity === ESLINT_ERROR);
-  const warnings = messages.filter((m) => m.severity === ESLINT_WARN);
+  const errors = kept.filter((m) => m.severity === ESLINT_ERROR);
+  const warnings = kept.filter((m) => m.severity === ESLINT_WARN);
   if (errors.length > 0) {
     lines.push(
       ...errors.map(
@@ -175,35 +125,9 @@ function formatLintMessages(messages, engine, warnLimit) {
   }));
   return {
     text: lines.length > 0 ? lines.join("\n") : void 0,
-    diagnostics,
-    engines: [engine.label]
+    diagnostics
   };
 }
-async function runEslintFiles(eslintClass, pattern, cwd, warnLimit) {
-  try {
-    const eslint = new eslintClass({ cwd });
-    const results = await eslint.lintFiles(pattern);
-    const messages = results.flatMap(
-      (r) => (r.messages ?? []).map((m) => ({ ...m, filePath: r.filePath }))
-    );
-    log.debug("ESLint lint", {
-      pattern,
-      fileCount: results.length,
-      messageCount: messages.length
-    });
-    return formatLintMessages(messages, { label: "ESLint", source: "eslint" }, warnLimit);
-  } catch (err) {
-    log.warn("ESLint failed", { pattern, error: err.message });
-    return {
-      text: `[ESLint] \u8FD0\u884C\u5931\u8D25\uFF1A${err.message}\uFF08\u4EC5\u663E\u793A TypeScript \u8BCA\u65AD\uFF09`,
-      diagnostics: [],
-      engines: ["ESLint"]
-    };
-  }
-}
-function resolveOxlintBin(workspace) {
-  return resolvePackageBin(import_node_path.default.join(workspace, "package.json"), "oxlint", "oxlint");
-}
 function oxlintRuleName(code) {
   if (!code) return null;
   const match = /\(([^)]*)\)$/.exec(code);
@@ -246,39 +170,6 @@ function parseOxlintOutput(stdout, cwd) {
     ];
   });
 }
-async function runOxlintFiles(pattern, cwd, warnLimit) {
-  const bin = resolveOxlintBin(cwd);
-  if (!bin) return {};
-  const result = await (0, import_execa.execa)(
-    "node",
-    [bin, "--format=json", "--ignore-pattern", "node_modules", pattern],
-    { cwd, timeout: 6e4, maxBuffer: 50 * 1024 * 1024, reject: false }
-  );
-  if (result.timedOut || result.isTerminated || result.isMaxBuffer) {
-    log.warn("oxlint timed out", { pattern });
-    return {
-      text: "[oxlint] \u8FD0\u884C\u5931\u8D25\uFF1A\u68C0\u67E5\u8D85\u65F6\uFF0C\u8BF7\u5C1D\u8BD5\u7F29\u5C0F\u68C0\u67E5\u8303\u56F4\u3002",
-      diagnostics: [],
-      engines: ["oxlint"]
-    };
-  }
-  try {
-    const messages = parseOxlintOutput(result.stdout, cwd);
-    log.debug("oxlint lint", {
-      pattern,
-      messageCount: messages.length,
-      stderr: result.stderr || void 0
-    });
-    return formatLintMessages(messages, { label: "oxlint", source: "oxlint" }, warnLimit);
-  } catch (e) {
-    log.warn("oxlint failed", { pattern, error: e.message });
-    return {
-      text: `[oxlint] \u8FD0\u884C\u5931\u8D25\uFF1A${e.message}`,
-      diagnostics: [],
-      engines: ["oxlint"]
-    };
-  }
-}
 const BUNDLED_ENGINE_KEY = "<bundled>";
 const _engineCache = /* @__PURE__ */ new Map();
 const _tsVersionCache = /* @__PURE__ */ new Map();
@@ -569,47 +460,9 @@ async function runTypeChecksForFiles(files, cwd) {
   }
   return results;
 }
-async function runAllChecks(pattern, cwd) {
-  log.debug("runAllChecks", { pattern, cwd });
-  const [eslintOutput, tscOutput] = await Promise.all([
-    lintFiles(pattern, cwd),
-    runTypeCheck(pattern, cwd)
-  ]);
-  return { eslintOutput, tscOutput };
-}
-async function runAllChecksForFiles(files, cwd) {
-  const targets = [...new Set(files.map((file) => import_node_path.default.resolve(file)))];
-  const tscByFile = await runTypeChecksForFiles(targets, cwd);
-  const results = /* @__PURE__ */ new Map();
-  for (const file of targets) {
-    results.set(file, {
-      eslintOutput: await lintFiles(file, cwd),
-      tscOutput: tscByFile.get(file) ?? { rawOutput: "", exitCode: 0 }
-    });
-  }
-  return results;
-}
-async function runProjectDiagnostics(workspace) {
-  const tscDirs = import_node_fs.default.existsSync(import_node_path.default.join(workspace, "tsconfig.json")) ? [workspace] : findAllTsconfigDirs(workspace);
-  log.debug("Tsc dirs to check", { count: tscDirs.length, dirs: tscDirs });
-  const [eslintOutput, ...tscOutputs] = await Promise.all([
-    lintFiles(".", workspace, 10),
-    ...tscDirs.map((dir) => runTypeCheck(void 0, dir))
-  ]);
-  const mergedTsc = {
-    rawOutput: tscOutputs.flatMap((o) => o.rawOutput).filter(Boolean).join("\n"),
-    exitCode: tscOutputs.reduce((max, o) => Math.max(max, o.exitCode), 0),
-    diagnostics: tscOutputs.flatMap((o) => o.diagnostics ?? []),
-    source: tscOutputs.find((o) => o.source)?.source
-  };
-  return { eslintOutput, tscOutput: mergedTsc };
-}
 function tscSectionTitle(tscOutput) {
   return tscOutput.source ?? "tsc";
 }
-function lintSectionTitle(lintOutput) {
-  return lintOutput.engines?.length ? lintOutput.engines.join(" + ") : "ESLint";
-}
 function omittedFindingsHint(omitted) {
   return `\u2026\u8FD8\u6709 ${omitted} \u6761\uFF0C\u5B8C\u6574\u7ED3\u679C\u8BF7\u8C03\u7528 run_diagnostics`;
 }
@@ -621,39 +474,493 @@ function boundFindings(text, maxFindings) {
     "\n"
   );
 }
-function formatDiagnosticsSections(title, eslintOutput, tscOutput, options = {}) {
-  const lintLines = boundFindings(eslintOutput.text, options.maxFindingsPerSection);
-  const tscLines = boundFindings(tscOutput.rawOutput.trim(), options.maxFindingsPerSection);
-  const parts = [];
-  if (!options.onlyFindings || lintLines) {
-    parts.push(`## ${lintSectionTitle(eslintOutput)}
-
-` + (lintLines || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898"));
+function displayPath(cwd, file) {
+  const rel = import_node_path.default.relative(cwd, file);
+  return rel.startsWith("..") || import_node_path.default.isAbsolute(rel) ? file : rel;
+}
+function targetFiles(target) {
+  if (target.kind === "file") return [import_node_path.default.resolve(target.file)];
+  if (target.kind === "edited") return [...new Set(target.files.map((file) => import_node_path.default.resolve(file)))];
+  return [];
+}
+function splitsByFile(target) {
+  return target.kind === "edited";
+}
+function filterBySeverity(items, severity) {
+  return severity === "error" ? items.filter((item) => item.severity === import_constants.SEVERITY_ERROR) : [...items];
+}
+function renderDiagnosticLines(items) {
+  return items.map((item) => {
+    const level = item.severity === import_constants.SEVERITY_ERROR ? "ERROR" : "WARN";
+    const file = item.file ?? "";
+    const { line, character } = item.range.start;
+    return `${level} [${file}:${line + 1}:${character + 1}] ${item.message}`;
+  }).join("\n");
+}
+function entryToDiagnosticItem(entry, source) {
+  return {
+    file: entry.file,
+    severity: entry.severity === "error" ? import_constants.SEVERITY_ERROR : import_constants.SEVERITY_WARN,
+    range: {
+      start: { line: entry.line - 1, character: entry.column - 1 },
+      end: { line: entry.line - 1, character: entry.column - 1 }
+    },
+    message: entry.message,
+    source
+  };
+}
+function normalizeEntries(value, source) {
+  if (value === void 0) return [];
+  if (!Array.isArray(value)) throw new Error("diagnostics \u5FC5\u987B\u662F\u6570\u7EC4");
+  return value.map((raw, index) => {
+    const at = `diagnostics[${index}]`;
+    if (!raw || typeof raw !== "object") throw new Error(`${at} \u5FC5\u987B\u662F\u5BF9\u8C61`);
+    const entry = raw;
+    if (typeof entry.file !== "string" || !entry.file)
+      throw new Error(`${at}.file \u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32`);
+    if (typeof entry.line !== "number" || entry.line < 1)
+      throw new Error(`${at}.line \u5FC5\u987B\u662F \u2265 1 \u7684\u6570\u5B57`);
+    if (typeof entry.column !== "number" || entry.column < 1)
+      throw new Error(`${at}.column \u5FC5\u987B\u662F \u2265 1 \u7684\u6570\u5B57`);
+    if (entry.severity !== "error" && entry.severity !== "warning")
+      throw new Error(`${at}.severity \u5FC5\u987B\u662F "error" \u6216 "warning"`);
+    if (typeof entry.message !== "string") throw new Error(`${at}.message \u5FC5\u987B\u662F\u5B57\u7B26\u4E32`);
+    return entryToDiagnosticItem(entry, source);
+  });
+}
+function extractJsonValue(raw) {
+  const trimmed = raw.trim();
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const starts = [raw.indexOf("{"), raw.indexOf("[")].filter((index) => index >= 0);
+    if (starts.length === 0) throw new Error("\u672A\u627E\u5230 JSON \u8F93\u51FA");
+    const start = Math.min(...starts);
+    const close = raw[start] === "{" ? "}" : "]";
+    const end = raw.lastIndexOf(close);
+    if (end <= start) throw new Error("\u672A\u627E\u5230 JSON \u8F93\u51FA");
+    return JSON.parse(raw.slice(start, end + 1));
   }
-  if (!options.onlyFindings || tscLines) {
-    parts.push(`## ${tscSectionTitle(tscOutput)}
-
-` + (tscLines || "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF"));
+}
+function parseEslintJson(raw, cwd) {
+  const parsed = extractJsonValue(raw);
+  if (!Array.isArray(parsed)) throw new Error("\u9876\u5C42\u5FC5\u987B\u662F\u6570\u7EC4");
+  const all = parsed.flatMap(
+    (file) => (file.messages ?? []).map((message) => ({
+      ...message,
+      filePath: file.filePath ? import_node_path.default.resolve(cwd, file.filePath) : ""
+    }))
+  );
+  return {
+    messages: all.filter((message) => message.filePath && !isEslintIgnoreNotice(message)),
+    ignored: all.filter((message) => message.filePath && isEslintIgnoreNotice(message)).map((m) => m.filePath)
+  };
+}
+function isEslintIgnoreNotice(message) {
+  return (message.ruleId ?? null) === null && typeof message.message === "string" && message.message.startsWith("File ignored because");
+}
+function filterTscOutputBySeverity(rawOutput, minSeverity) {
+  if (minSeverity === "warning" || !rawOutput) return rawOutput;
+  const errorLinePat = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+TS\d+:/;
+  const kept = [];
+  let keep = false;
+  for (const line of rawOutput.split("\n")) {
+    const match = errorLinePat.exec(line);
+    if (match) keep = match[4] === "error";
+    else if (!/^\s/.test(line)) keep = false;
+    if (keep) kept.push(line);
   }
-  if (parts.length === 0) return "";
-  const body = parts.join("\n\n");
-  return title ? `${title}
+  return kept.join("\n");
+}
+function applyTscSeverity(result, minSeverity) {
+  if (minSeverity === "warning") return result;
+  return {
+    ...result,
+    rawOutput: filterTscOutputBySeverity(result.rawOutput, minSeverity),
+    diagnostics: (result.diagnostics ?? []).filter((item) => item.severity === import_constants.SEVERITY_ERROR)
+  };
+}
+function emptySectionText(kind, phase, severity) {
+  if (phase !== "manual") return void 0;
+  if (kind === "typecheck") return "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF";
+  return severity === "error" ? "\u6CA1\u6709\u53D1\u73B0\u9519\u8BEF" : "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898";
+}
+function buildSection(name, target, outcome, phase, severity, kind) {
+  const diagnostics = filterBySeverity(outcome.diagnostics ?? [], severity);
+  const explicit = (outcome.text ?? "").trim();
+  const body = explicit || (diagnostics.length > 0 ? renderDiagnosticLines(diagnostics) : emptySectionText(kind, phase, severity) ?? "");
+  const notes = phase === "manual" ? (outcome.notes ?? []).filter(Boolean) : [];
+  const text = [body, ...notes].filter(Boolean).join("\n\n");
+  return {
+    name,
+    ...target ? { target } : {},
+    ...text ? { text } : {},
+    diagnostics
+  };
+}
+function resolveCommandSource(check, cwd) {
+  if (check.command) {
+    return { command: check.command, prefix: [], label: check.command };
+  }
+  const binName = check.bin;
+  const bin = resolvePackageBin(import_node_path.default.join(cwd, "package.json"), binName, binName);
+  if (!bin) {
+    return {
+      command: "node",
+      prefix: [],
+      label: binName,
+      error: `\u9879\u76EE\u91CC\u89E3\u6790\u4E0D\u5230 ${binName}\uFF08\u8BF7\u5148\u5B89\u88C5\u8BE5\u4F9D\u8D56\uFF0C\u6216\u6539\u7528 command \u6307\u5B9A\u53EF\u6267\u884C\u6587\u4EF6\uFF09`
+    };
+  }
+  return { command: "node", prefix: [bin], label: binName };
+}
+async function runCommand(check, source, argv, cwd) {
+  const result = await (0, import_execa.execa)(source.command, [...source.prefix, ...argv], {
+    cwd,
+    timeout: check.timeoutMs ?? import_diagnostics.COMMAND_CHECK_TIMEOUT_MS,
+    maxBuffer: 10 * 1024 * 1024,
+    reject: false,
+    stdin: "ignore"
+  });
+  return {
+    stdout: String(result.stdout ?? ""),
+    stderr: String(result.stderr ?? ""),
+    exitCode: typeof result.exitCode === "number" ? result.exitCode : void 0,
+    failed: result.failed,
+    timedOut: Boolean(result.timedOut || result.isTerminated),
+    overflowed: Boolean(result.isMaxBuffer),
+    message: result.originalMessage
+  };
+}
+function commandFailureText(check, source, outcome) {
+  if (outcome.timedOut) {
+    return `[${check.name}] \u8FD0\u884C\u5931\u8D25\uFF1A\u68C0\u67E5\u8D85\u65F6\uFF08${check.timeoutMs ?? import_diagnostics.COMMAND_CHECK_TIMEOUT_MS}ms\uFF09\uFF0C\u53EF\u63D0\u9AD8 diagnostics.timeoutMs \u6216\u7F29\u5C0F\u68C0\u67E5\u8303\u56F4\u3002`;
+  }
+  if (outcome.overflowed) return `[${check.name}] \u8FD0\u884C\u5931\u8D25\uFF1A\u8F93\u51FA\u8D85\u8FC7\u4E0A\u9650\uFF0C\u8BF7\u7F29\u5C0F\u68C0\u67E5\u8303\u56F4\u3002`;
+  if (outcome.failed && outcome.exitCode === void 0) {
+    return `[${check.name}] \u8FD0\u884C\u5931\u8D25\uFF1A\u65E0\u6CD5\u6267\u884C ${source.label}\uFF08${outcome.message ?? "spawn failed"}\uFF09\u3002`;
+  }
+  return void 0;
+}
+function rawCommandOutput(outcome) {
+  return [outcome.stdout, outcome.stderr].map((text) => text.trim()).filter(Boolean).join("\n");
+}
+function expandArgs(args, files) {
+  return args.flatMap((arg) => {
+    if (arg === "{file}") return files[0] ? [files[0]] : [];
+    if (arg === "{files}") return [...files];
+    return [
+      arg.replace(
+        /\{file\}|\{files\}/g,
+        (match) => match === "{file}" ? files[0] ?? "" : files.join(" ")
+      )
+    ];
+  });
+}
+async function runAdapterModule(check, outcome, cwd, files) {
+  const adapterPath = import_node_path.default.resolve(cwd, check.adapter);
+  const fail = (reason) => ({
+    text: `[${check.name}] \u9002\u914D\u5668\u4E0D\u53EF\u7528\uFF1A${check.adapter}\uFF08${reason}\uFF09`,
+    diagnostics: []
+  });
+  let moduleExports;
+  try {
+    moduleExports = await import((0, import_node_url.pathToFileURL)(adapterPath).href);
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+  if (typeof moduleExports.default !== "function") {
+    return fail("\u6A21\u5757\u5FC5\u987B default export \u4E00\u4E2A\u9002\u914D\u5668\u51FD\u6570");
+  }
+  const input = {
+    name: check.name,
+    stdout: outcome.stdout,
+    stderr: outcome.stderr,
+    exitCode: outcome.exitCode,
+    files: [...files],
+    cwd
+  };
+  let output;
+  try {
+    output = await moduleExports.default(
+      input
+    );
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+  if (!output || typeof output !== "object") return fail("\u9002\u914D\u5668\u5FC5\u987B\u8FD4\u56DE\u5BF9\u8C61");
+  try {
+    const diagnostics = normalizeEntries(output.diagnostics, check.name);
+    return { text: diagnostics.length > 0 ? void 0 : output.text, diagnostics };
+  } catch (error) {
+    return fail(error instanceof Error ? error.message : String(error));
+  }
+}
+function parseStylelintJson(raw, cwd) {
+  const parsed = extractJsonValue(raw);
+  if (!Array.isArray(parsed)) throw new Error("\u9876\u5C42\u5FC5\u987B\u662F\u6570\u7EC4");
+  return parsed.flatMap((file) => {
+    const filePath = file.source ? import_node_path.default.resolve(cwd, file.source) : "";
+    if (!filePath) return [];
+    return (file.warnings ?? []).map((warning) => ({
+      severity: warning.severity === "error" ? 2 : 1,
+      line: warning.line ?? 1,
+      column: warning.column ?? 1,
+      endLine: warning.endLine,
+      endColumn: warning.endColumn,
+      message: warning.text ?? "\u672A\u77E5\u8BCA\u65AD",
+      ruleId: warning.rule ?? null,
+      filePath
+    }));
+  });
+}
+function adaptBuiltinFormat(format, check, raw, cwd, severity) {
+  const lintFromMessages = (messages) => {
+    const output = formatLintMessages(
+      messages,
+      { label: check.name, source: check.name },
+      10,
+      severity
+    );
+    return { text: output.text, diagnostics: output.diagnostics ?? [] };
+  };
+  switch (format) {
+    case "tsc":
+      return {
+        text: filterTscOutputBySeverity(raw, severity),
+        diagnostics: parseTscDiags(raw, void 0, cwd, check.name)
+      };
+    case "eslint-json": {
+      const { messages, ignored } = parseEslintJson(raw, cwd);
+      return {
+        ...lintFromMessages(messages),
+        notes: ignored.map((file) => `${file} \u4E0D\u5728 ESLint \u914D\u7F6E\u8303\u56F4\u5185\uFF0C\u672A\u68C0\u67E5`)
+      };
+    }
+    case "oxlint-json":
+      return lintFromMessages(parseOxlintOutput(raw, cwd));
+    case "stylelint-json":
+      return lintFromMessages(parseStylelintJson(raw, cwd));
+    case "aipanel-json": {
+      const value = extractJsonValue(raw);
+      const payload = Array.isArray(value) ? { diagnostics: value } : value;
+      const diagnostics = normalizeEntries(payload?.diagnostics, check.name);
+      return { text: diagnostics.length > 0 ? void 0 : payload?.text, diagnostics };
+    }
+    case "text":
+    default:
+      return { text: raw, diagnostics: [] };
+  }
+}
+function expandLinterPreset(check) {
+  const spec = import_diagnostics.BUILTIN_LINTERS[check.builtin];
+  return {
+    name: spec.label,
+    bin: spec.bin ?? spec.package,
+    args: check.args ?? [...spec.args],
+    ...check.projectArgs ?? spec.projectArgs ? { projectArgs: [...check.projectArgs ?? spec.projectArgs ?? []] } : {},
+    extensions: check.extensions ?? [...spec.extensions],
+    format: check.format ?? spec.format,
+    ...check.run ? { run: check.run } : {},
+    ...check.cwd ? { cwd: check.cwd } : {},
+    ...check.timeoutMs ? { timeoutMs: check.timeoutMs } : {}
+  };
+}
+async function runCommandCheck(check, target, phase, severity, optional = false) {
+  const cwd = check.cwd ? import_node_path.default.resolve(target.cwd, check.cwd) : target.cwd;
+  const args = check.args ?? [];
+  const hasPlaceholder = args.some((arg) => arg.includes("{file}") || arg.includes("{files}"));
+  const perFile = args.some((arg) => arg.includes("{file}"));
+  const split = splitsByFile(target);
+  const targeted = target.kind !== "project";
+  const files = targeted ? targetFiles(target).filter((file) => (0, import_diagnostics.matchesExtensions)(file, check.extensions)) : [];
+  if (targeted && hasPlaceholder && files.length === 0) {
+    log.debug("skip command check: no matching file target", { name: check.name, phase });
+    return [];
+  }
+  const source = resolveCommandSource(check, cwd);
+  if (source.error) {
+    if (optional && phase === "edit") {
+      log.debug("skip uninstalled builtin linter", { name: check.name });
+      return [];
+    }
+    const text = optional ? `[${check.name}] \u672A\u8FD0\u884C\uFF1A${source.error}` : `[${check.name}] ${source.error}`;
+    return [buildSection(check.name, void 0, { text }, phase, severity, "command")];
+  }
+  const execute = async (argvTemplate, fileSet) => {
+    const outcome = await runCommand(check, source, expandArgs(argvTemplate, fileSet), cwd);
+    const failure = commandFailureText(check, source, outcome);
+    if (failure) return { text: failure, diagnostics: [] };
+    const raw = rawCommandOutput(outcome);
+    try {
+      if (check.adapter) return await runAdapterModule(check, outcome, cwd, fileSet);
+      return adaptBuiltinFormat(check.format ?? "text", check, raw, cwd, severity);
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      const excerpt = raw.replace(/\s+/g, " ").trim().slice(0, 200);
+      return {
+        text: `[${check.name}] \u8FD0\u884C\u5931\u8D25\uFF1A\u8F93\u51FA\u89E3\u6790\u5931\u8D25\uFF08${reason}\uFF09${excerpt ? `\uFF1A${excerpt}` : ""}`,
+        diagnostics: []
+      };
+    }
+  };
+  const targetLabel = (file) => split ? displayPath(target.cwd, file) : void 0;
+  if (!hasPlaceholder) {
+    return [
+      buildSection(check.name, void 0, await execute(args, []), phase, severity, "command")
+    ];
+  }
+  if (target.kind === "project") {
+    if (!check.projectArgs) {
+      log.debug("skip command check: no project args", { name: check.name });
+      return [];
+    }
+    return [
+      buildSection(
+        check.name,
+        void 0,
+        await execute(check.projectArgs, []),
+        phase,
+        severity,
+        "command"
+      )
+    ];
+  }
+  if (perFile) {
+    const sections = [];
+    for (const file of files) {
+      const produced2 = await execute(args, [file]);
+      sections.push(
+        buildSection(check.name, targetLabel(file), produced2, phase, severity, "command")
+      );
+    }
+    return sections;
+  }
+  const produced = await execute(args, files);
+  const label = files.length === 1 ? targetLabel(files[0]) : void 0;
+  return [buildSection(check.name, label, produced, phase, severity, "command")];
+}
+async function runProjectTypeCheck(workspace, severity) {
+  const dirs = import_node_fs.default.existsSync(import_node_path.default.join(workspace, "tsconfig.json")) ? [workspace] : findAllTsconfigDirs(workspace);
+  log.debug("Tsc dirs to check", { count: dirs.length, dirs });
+  const results = await Promise.all(dirs.map((dir) => runTypeCheck(void 0, dir)));
+  return applyTscSeverity(
+    {
+      rawOutput: results.flatMap((output) => output.rawOutput).filter(Boolean).join("\n"),
+      exitCode: results.reduce((max, output) => Math.max(max, output.exitCode), 0),
+      diagnostics: results.flatMap((output) => output.diagnostics ?? []),
+      source: results.find((output) => output.source)?.source
+    },
+    severity
+  );
+}
+async function runTypecheckCheck(check, target, phase, severity) {
+  const cwd = target.cwd;
+  const split = splitsByFile(target);
+  const files = target.kind === "project" ? [] : targetFiles(target).filter(
+    (file) => (0, import_diagnostics.matchesExtensions)(file, check.extensions ?? import_diagnostics.SOURCE_EXTENSIONS)
+  );
+  if (target.kind !== "project" && files.length === 0) {
+    log.debug("skip builtin check: no matching file target", { builtin: check.builtin, phase });
+    return [];
+  }
+  if (split) {
+    const results = await runTypeChecksForFiles(files, cwd);
+    return files.map((file) => {
+      const result2 = applyTscSeverity(
+        results.get(import_node_path.default.resolve(file)) ?? { rawOutput: "", exitCode: 0 },
+        severity
+      );
+      return buildSection(
+        tscSectionTitle(result2),
+        displayPath(cwd, file),
+        { text: result2.rawOutput.trim(), diagnostics: result2.diagnostics },
+        phase,
+        severity,
+        "typecheck"
+      );
+    });
+  }
+  const result = target.kind === "file" ? applyTscSeverity(await runTypeCheck(files[0], cwd), severity) : await runProjectTypeCheck(cwd, severity);
+  return [
+    buildSection(
+      tscSectionTitle(result),
+      void 0,
+      { text: result.rawOutput.trim(), diagnostics: result.diagnostics },
+      phase,
+      severity,
+      "typecheck"
+    )
+  ];
+}
+async function runDiagnostics(target, policy, phase) {
+  const checks = policy.checks.filter((check) => (0, import_diagnostics.checkRunsInPhase)(check, phase));
+  log.debug("runDiagnostics", { phase, target: target.kind, checks: checks.length });
+  const results = await Promise.all(
+    checks.map((check) => {
+      if ((0, import_diagnostics.isTypecheckCheck)(check)) {
+        return runTypecheckCheck(check, target, phase, policy.severity);
+      }
+      if ((0, import_diagnostics.isLinterPreset)(check)) {
+        return runCommandCheck(expandLinterPreset(check), target, phase, policy.severity, true);
+      }
+      if ((0, import_diagnostics.isCommandCheck)(check)) {
+        return runCommandCheck(check, target, phase, policy.severity);
+      }
+      return Promise.resolve([]);
+    })
+  );
+  const sections = results.flat().filter((section) => section.text !== void 0 || section.diagnostics.length > 0);
+  if (sections.length === 0 && phase === "manual") {
+    return {
+      sections: [
+        {
+          name: "\u68C0\u67E5",
+          text: "\u6CA1\u6709\u53EF\u8FD0\u884C\u7684\u68C0\u67E5\uFF1A\u5DF2\u914D\u7F6E\u7684\u68C0\u67E5\u90FD\u4E0D\u5339\u914D\u672C\u8F6E\u76EE\u6807\uFF08\u68C0\u67E5\u7684 extensions / run \u9636\u6BB5 / \u76EE\u6807\u7C7B\u578B\uFF09\u3002",
+          diagnostics: []
+        }
+      ]
+    };
+  }
+  return { sections };
+}
+function collectDiagnostics(result) {
+  return result.sections.flatMap((section) => section.diagnostics);
+}
+function renderDiagnostics(result, options = {}) {
+  const sections = options.onlyFindings ? result.sections.filter((section) => (section.text ?? "").trim()) : result.sections;
+  if (sections.length === 0) return "";
+  const groups = /* @__PURE__ */ new Map();
+  for (const section of sections) {
+    const key = section.target ?? "";
+    const group = groups.get(key);
+    if (group) group.push(section);
+    else groups.set(key, [section]);
+  }
+  const blocks = [];
+  for (const [key, group] of groups) {
+    const body = group.map((section) => {
+      const text = boundFindings(section.text, options.maxFindingsPerSection);
+      return `## ${section.name}
 
-${body}` : body;
+${text || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898"}`;
+    }).join("\n\n");
+    blocks.push(key ? `### ${key}
+
+${body}` : body);
+  }
+  return blocks.join("\n\n");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DIAGNOSTICS_TOOL_DESCRIPTION,
+  collectDiagnostics,
   findAllTsconfigDirs,
   findTsconfigDir,
-  formatDiagnosticsSections,
   isJsFile,
-  lintFiles,
-  lintSectionTitle,
   omittedFindingsHint,
-  runAllChecks,
-  runAllChecksForFiles,
-  runProjectDiagnostics,
+  renderDiagnostics,
+  runDiagnostics,
   runTypeCheck,
   runTypeChecksForFiles,
   tscSectionTitle