@aipanel/core 1.3.4 → 1.3.6

package/es/node.d.ts

@@ -1,4 +1,5 @@
 export * from "./common/constants";
+export * from "./common/diagnostics";
 export * from "./common/logger-core";
 export * from "./node/node-logger";
 export * from "./node/process-logger";

package/es/node.mjs

@@ -1,4 +1,5 @@
 export * from "./common/constants.mjs";
+export * from "./common/diagnostics.mjs";
 export * from "./common/logger-core.mjs";
 export * from "./node/node-logger.mjs";
 export * from "./node/process-logger.mjs";

package/lib/common/constants.cjs

@@ -203,7 +203,8 @@ const OPENCODE_ENV = {
   VITE_LOGS_API_URL: "OPENCODE_VITE_LOGS_API_URL",
   LOG_FILES_JSON: "OPENCODE_LOG_FILES_JSON",
   VERBOSE: "OPENCODE_VERBOSE",
-  ENABLE_LINT: "OPENCODE_ENABLE_LINT",
+  /** 诊断策略 JSON（DiagnosticsPolicy）：provider 写，opencode 插件读 */
+  DIAGNOSTICS: "OPENCODE_DIAGNOSTICS",
   VUE_DEVTOOLS_API_URL: "OPENCODE_VUE_DEVTOOLS_API_URL",
   WORKSPACE: "OPENCODE_WORKSPACE"
 };

package/lib/common/constants.d.ts

@@ -196,14 +196,15 @@ export declare const MUTATING_TOOLS: ReadonlySet<string>;
 /** 挂件主题可选值（对应 AIPanelWidgetTheme） */
 export declare const WIDGET_THEME_MODES: readonly ["auto", "light", "dark"];
 /** ==================== OpenCode 环境变量名 ==================== */
-/** OpenCode 相关环境变量名（opencode provider 写、es/plugins 与 dsh-plugin 读，统一引用防止字面量漂移） */
+/** OpenCode 相关环境变量名（opencode provider 写、es/plugins 读，统一引用防止字面量漂移） */
 export declare const OPENCODE_ENV: {
     readonly CONFIG_DIR: "OPENCODE_CONFIG_DIR";
     readonly CONTEXT_API_URL: "OPENCODE_CONTEXT_API_URL";
     readonly VITE_LOGS_API_URL: "OPENCODE_VITE_LOGS_API_URL";
     readonly LOG_FILES_JSON: "OPENCODE_LOG_FILES_JSON";
     readonly VERBOSE: "OPENCODE_VERBOSE";
-    readonly ENABLE_LINT: "OPENCODE_ENABLE_LINT";
+    /** 诊断策略 JSON（DiagnosticsPolicy）：provider 写，opencode 插件读 */
+    readonly DIAGNOSTICS: "OPENCODE_DIAGNOSTICS";
     readonly VUE_DEVTOOLS_API_URL: "OPENCODE_VUE_DEVTOOLS_API_URL";
     readonly WORKSPACE: "OPENCODE_WORKSPACE";
 };

package/lib/common/diagnostics.cjs

@@ -0,0 +1,261 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var diagnostics_exports = {};
+__export(diagnostics_exports, {
+  BUILTIN_LINTERS: () => BUILTIN_LINTERS,
+  COMMAND_CHECK_TIMEOUT_MS: () => COMMAND_CHECK_TIMEOUT_MS,
+  DEFAULT_BUILTIN_CHECKS: () => DEFAULT_BUILTIN_CHECKS,
+  DEFAULT_DIAGNOSTICS_POLICY: () => DEFAULT_DIAGNOSTICS_POLICY,
+  DEFAULT_MAX_FINDINGS_PER_SECTION: () => DEFAULT_MAX_FINDINGS_PER_SECTION,
+  DEFAULT_MAX_MESSAGE_CHARS: () => DEFAULT_MAX_MESSAGE_CHARS,
+  SOURCE_EXTENSIONS: () => SOURCE_EXTENSIONS,
+  checkRunsInPhase: () => checkRunsInPhase,
+  isCommandCheck: () => isCommandCheck,
+  isLinterPreset: () => isLinterPreset,
+  isTypecheckCheck: () => isTypecheckCheck,
+  matchesExtensions: () => matchesExtensions,
+  resolveDiagnosticsPolicy: () => resolveDiagnosticsPolicy
+});
+module.exports = __toCommonJS(diagnostics_exports);
+const COMMAND_CHECK_TIMEOUT_MS = 6e4;
+const SOURCE_EXTENSIONS = [
+  ".js",
+  ".jsx",
+  ".ts",
+  ".tsx",
+  ".mjs",
+  ".cjs",
+  ".mts",
+  ".cts",
+  ".vue"
+];
+function matchesExtensions(filePath, extensions) {
+  if (!extensions?.length) return true;
+  const base = filePath.replace(/\\/g, "/").split("/").pop() ?? "";
+  const dot = base.lastIndexOf(".");
+  if (dot <= 0) return false;
+  return extensions.includes(base.slice(dot).toLowerCase());
+}
+const BUILTIN_LINTERS = {
+  eslint: {
+    label: "ESLint",
+    package: "eslint",
+    args: ["--format", "json", "{files}"],
+    projectArgs: ["--format", "json", "."],
+    extensions: [...SOURCE_EXTENSIONS],
+    format: "eslint-json"
+  },
+  oxlint: {
+    label: "oxlint",
+    package: "oxlint",
+    args: ["--format=json", "--ignore-pattern", "node_modules", "{files}"],
+    projectArgs: ["--format=json", "--ignore-pattern", "node_modules", "."],
+    extensions: [...SOURCE_EXTENSIONS],
+    format: "oxlint-json"
+  },
+  stylelint: {
+    label: "Stylelint",
+    package: "stylelint",
+    args: ["--formatter", "json", "{files}"],
+    projectArgs: ["--formatter", "json", "**/*.{css,scss,less}"],
+    extensions: [".css", ".scss", ".less"],
+    format: "stylelint-json"
+  }
+};
+const DEFAULT_MAX_FINDINGS_PER_SECTION = 3;
+const DEFAULT_MAX_MESSAGE_CHARS = 4e3;
+const DEFAULT_BUILTIN_CHECKS = Object.freeze([
+  Object.freeze({ builtin: "eslint" }),
+  Object.freeze({ builtin: "oxlint" }),
+  Object.freeze({ builtin: "typecheck" })
+]);
+const DEFAULT_DIAGNOSTICS_POLICY = Object.freeze({
+  checks: DEFAULT_BUILTIN_CHECKS.map((check) => ({ ...check })),
+  auto: true,
+  exposeTool: true,
+  severity: "warning",
+  maxFindingsPerSection: DEFAULT_MAX_FINDINGS_PER_SECTION,
+  maxMessageChars: DEFAULT_MAX_MESSAGE_CHARS
+});
+function isCommandCheck(check) {
+  return !("builtin" in check);
+}
+function isLinterPreset(check) {
+  return "builtin" in check && check.builtin !== "typecheck";
+}
+function isTypecheckCheck(check) {
+  return "builtin" in check && check.builtin === "typecheck";
+}
+function checkRunsInPhase(check, phase) {
+  const run = check.run ?? "both";
+  return run === "both" || run === phase;
+}
+const FORMATS = [
+  "text",
+  "tsc",
+  "eslint-json",
+  "oxlint-json",
+  "stylelint-json",
+  "aipanel-json"
+];
+const RUNS = ["edit", "manual", "both"];
+function normalizeExtensions(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const extensions = raw.filter((item) => typeof item === "string" && item.trim() !== "").map((item) => {
+    const trimmed = item.trim().toLowerCase();
+    return trimmed.startsWith(".") ? trimmed : `.${trimmed}`;
+  });
+  return extensions.length > 0 ? [...new Set(extensions)] : void 0;
+}
+function normalizeArgs(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const args = raw.filter((item) => typeof item === "string");
+  return args.length > 0 ? args : void 0;
+}
+function normalizeCheck(raw) {
+  if (!raw || typeof raw !== "object") return void 0;
+  const value = raw;
+  const run = RUNS.includes(value.run) ? value.run : void 0;
+  const extensions = normalizeExtensions(value.extensions);
+  const cwd = typeof value.cwd === "string" && value.cwd ? { cwd: value.cwd } : {};
+  const timeout = typeof value.timeoutMs === "number" && Number.isFinite(value.timeoutMs) && value.timeoutMs > 0 ? { timeoutMs: Math.floor(value.timeoutMs) } : {};
+  const format = FORMATS.includes(value.format) ? { format: value.format } : {};
+  if (value.builtin !== void 0) {
+    if (value.builtin === "typecheck") {
+      return {
+        builtin: "typecheck",
+        ...run ? { run } : {},
+        ...extensions ? { extensions } : {}
+      };
+    }
+    if (typeof value.builtin === "string" && value.builtin in BUILTIN_LINTERS) {
+      const presetArgs = normalizeArgs(value.args);
+      const presetProjectArgs = normalizeArgs(value.projectArgs);
+      return {
+        builtin: value.builtin,
+        ...presetArgs ? { args: presetArgs } : {},
+        ...presetProjectArgs ? { projectArgs: presetProjectArgs } : {},
+        ...extensions ? { extensions } : {},
+        ...run ? { run } : {},
+        ...format,
+        ...cwd,
+        ...timeout
+      };
+    }
+    return void 0;
+  }
+  if (typeof value.name !== "string" || !value.name) return void 0;
+  const command = typeof value.command === "string" && value.command ? value.command : void 0;
+  const bin = typeof value.bin === "string" && value.bin ? value.bin : void 0;
+  if (!command && !bin) return void 0;
+  const args = normalizeArgs(value.args);
+  const projectArgs = normalizeArgs(value.projectArgs);
+  return {
+    name: value.name,
+    ...command ? { command } : {},
+    ...bin ? { bin } : {},
+    ...args ? { args } : {},
+    ...projectArgs ? { projectArgs } : {},
+    ...extensions ? { extensions } : {},
+    ...cwd,
+    ...run ? { run } : {},
+    ...format,
+    ...typeof value.adapter === "string" && value.adapter ? { adapter: value.adapter } : {},
+    ...timeout
+  };
+}
+function normalizeChecks(raw, onInvalid) {
+  if (raw === void 0) return void 0;
+  if (!Array.isArray(raw)) {
+    onInvalid("diagnostics.checks \u5FC5\u987B\u662F\u6570\u7EC4\uFF0C\u5DF2\u56DE\u9000\u4E3A\u5185\u7F6E\u68C0\u67E5");
+    return void 0;
+  }
+  const checks = [];
+  for (const item of raw) {
+    const check = normalizeCheck(item);
+    if (check) checks.push(check);
+    else onInvalid(`diagnostics.checks \u542B\u975E\u6CD5\u68C0\u67E5\u9879\uFF0C\u5DF2\u8DF3\u8FC7\uFF1A${JSON.stringify(item)}`);
+  }
+  if (checks.length === 0) {
+    onInvalid("diagnostics.checks \u5F52\u4E00\u5316\u540E\u4E3A\u7A7A\uFF0C\u5DF2\u56DE\u9000\u4E3A\u5185\u7F6E\u68C0\u67E5");
+    return void 0;
+  }
+  return checks;
+}
+function normalizeBoolean(raw, fallback) {
+  return typeof raw === "boolean" ? raw : fallback;
+}
+function isValidPositiveInt(raw) {
+  return typeof raw === "number" && Number.isFinite(raw) && raw >= 1;
+}
+function normalizePositiveInt(raw, fallback) {
+  return isValidPositiveInt(raw) ? Math.floor(raw) : fallback;
+}
+function resolveDiagnosticsPolicy(layers, onInvalid = () => {
+}) {
+  let policy = {
+    ...DEFAULT_DIAGNOSTICS_POLICY,
+    checks: DEFAULT_BUILTIN_CHECKS.map((check) => ({ ...check }))
+  };
+  for (const layer of layers) {
+    if (!layer || typeof layer !== "object") continue;
+    const checks = normalizeChecks(layer.checks, onInvalid);
+    if (layer.severity !== void 0 && layer.severity !== "error" && layer.severity !== "warning") {
+      onInvalid(`diagnostics.severity \u53D6\u503C\u975E\u6CD5\uFF08${String(layer.severity)}\uFF09\uFF0C\u5DF2\u56DE\u9000\u4E0A\u4E00\u5C42`);
+    }
+    if (layer.maxFindingsPerSection !== void 0 && !isValidPositiveInt(layer.maxFindingsPerSection)) {
+      onInvalid("diagnostics.maxFindingsPerSection \u5FC5\u987B\u662F \u2265 1 \u7684\u6574\u6570\uFF0C\u5DF2\u56DE\u9000\u4E0A\u4E00\u5C42");
+    }
+    if (layer.maxMessageChars !== void 0 && !isValidPositiveInt(layer.maxMessageChars)) {
+      onInvalid("diagnostics.maxMessageChars \u5FC5\u987B\u662F \u2265 1 \u7684\u6574\u6570\uFF0C\u5DF2\u56DE\u9000\u4E0A\u4E00\u5C42");
+    }
+    for (const key of ["auto", "exposeTool"]) {
+      if (layer[key] !== void 0 && typeof layer[key] !== "boolean") {
+        onInvalid(`diagnostics.${key} \u5FC5\u987B\u662F\u5E03\u5C14\u503C\uFF0C\u5DF2\u56DE\u9000\u4E0A\u4E00\u5C42`);
+      }
+    }
+    policy = {
+      checks: checks ? checks.map((check) => ({ ...check })) : policy.checks,
+      auto: normalizeBoolean(layer.auto, policy.auto),
+      exposeTool: normalizeBoolean(layer.exposeTool, policy.exposeTool),
+      severity: layer.severity === "error" || layer.severity === "warning" ? layer.severity : policy.severity,
+      maxFindingsPerSection: normalizePositiveInt(
+        layer.maxFindingsPerSection,
+        policy.maxFindingsPerSection
+      ),
+      maxMessageChars: normalizePositiveInt(layer.maxMessageChars, policy.maxMessageChars)
+    };
+  }
+  return policy;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUILTIN_LINTERS,
+  COMMAND_CHECK_TIMEOUT_MS,
+  DEFAULT_BUILTIN_CHECKS,
+  DEFAULT_DIAGNOSTICS_POLICY,
+  DEFAULT_MAX_FINDINGS_PER_SECTION,
+  DEFAULT_MAX_MESSAGE_CHARS,
+  SOURCE_EXTENSIONS,
+  checkRunsInPhase,
+  isCommandCheck,
+  isLinterPreset,
+  isTypecheckCheck,
+  matchesExtensions,
+  resolveDiagnosticsPolicy
+});

package/lib/common/diagnostics.d.ts

@@ -0,0 +1,199 @@
+/**
+ * 诊断的用户配置契约（provider 无关）。
+ *
+ * 用户配置面只有一处：vite 插件的 `providerOptions.diagnostics`。核心层在这里定义策略形状、
+ * 检查来源（内置引擎 / 项目命令）、输出适配器协议与默认值；两个 provider（deepseek / opencode）
+ * 与两侧宿主插件共用同一份语义，因此"用户配置了什么"在每个宿主上含义一致。
+ *
+ * 不在这里定义的东西：排除规则（ignore）—— 那是底层工具的事（ESLint 自身 ignore、tsconfig
+ * `exclude`、命令自己的 glob），我们不复制一套 glob 语义。
+ */
+import type { AIPanelDiagnosticEntry } from "./types";
+/** 诊断阶段：编辑后自动诊断 / agent 手动调用工具 */
+export type DiagnosticsPhase = "edit" | "manual";
+/** 检查在哪些阶段执行（缺省 both） */
+export type DiagnosticsRun = DiagnosticsPhase | "both";
+/**
+ * 类型检查检查：唯一的"引擎级"内置（要 tsconfig 感知的批量归并、项目本地 tsc/vue-tsc 探测
+ * 与自带 vue-tsc 兜底，不是一条命令能表达的）。其余一切检查都走同一条命令执行路径。
+ */
+export interface TypecheckCheck {
+    builtin: "typecheck";
+    run?: DiagnosticsRun;
+    /** 只吃这些扩展名（如 [".ts", ".vue"]）；缺省 = 可诊断源码扩展名（与历史行为一致） */
+    extensions?: string[];
+}
+/** 命令输出的内置适配器名（内置适配器由我们开发维护） */
+export type DiagnosticsFormat = "text" | "tsc" | "eslint-json" | "oxlint-json" | "stylelint-json" | "aipanel-json";
+/**
+ * 命令检查：跑用户项目里的一条命令（或项目本地某个包的 bin），输出经适配器归一成分区。
+ *
+ * 命令按 argv 直传、不经 shell（见 ADR-0002）；需要 shell 语义时由用户显式选择解释器。
+ * `command` 与 `bin` 二选一：`bin` 走"项目本地包解析"（与内置预设同一策略），
+ * 因此 stylelint / biome / 自研工具包都是同一条路，不需要为每个工具内置特判。
+ */
+export interface CommandCheck {
+    /** 分区标题（模型与诊断卡片都看到它） */
+    name: string;
+    /** argv[0]：命令名（PATH 解析）或路径；与 `bin` 二选一 */
+    command?: string;
+    /** 项目本地包的 bin 名（同时也是包名）：解析不到时给明确文案；与 `command` 二选一 */
+    bin?: string;
+    /** argv[1..]；可含 `{file}`（逐文件）与 `{files}`（一次传全部）占位符 */
+    args?: string[];
+    /**
+     * 无目标文件（全量诊断）时的 argv。
+     * 含占位符的检查没写它 → 全量诊断跳过该检查；不带占位符的检查三种目标都跑同一个 argv。
+     */
+    projectArgs?: string[];
+    /** 只吃这些扩展名（如 [".css", ".scss"]）；缺省 = 不限 */
+    extensions?: string[];
+    /** 相对项目根，默认项目根 */
+    cwd?: string;
+    run?: DiagnosticsRun;
+    /** 内置适配器名；与 `adapter` 同时给出时 `adapter` 优先 */
+    format?: DiagnosticsFormat;
+    /** 用户适配器模块路径（相对项目根）；default export 一个 {@link DiagnosticsAdapter} */
+    adapter?: string;
+    /** 命令超时（ms），默认 {@link COMMAND_CHECK_TIMEOUT_MS} */
+    timeoutMs?: number;
+}
+/**
+ * 内置 linter 预设：只写 `builtin: "eslint"` 就能用——包名 / bin / 默认 argv / 输出格式 /
+ * 扩展名都取 {@link BUILTIN_LINTERS} 的目录项，展开后与用户自定义的 {@link CommandCheck}
+ * **完全同形**，走同一条执行与适配逻辑。可局部覆盖（args / extensions / format / run …）。
+ */
+export type LinterPresetCheck = {
+    builtin: BuiltinLinterId;
+    args?: string[];
+    projectArgs?: string[];
+    extensions?: string[];
+    format?: DiagnosticsFormat;
+    cwd?: string;
+    run?: DiagnosticsRun;
+    timeoutMs?: number;
+};
+export type DiagnosticsCheck = TypecheckCheck | LinterPresetCheck | CommandCheck;
+/** 诊断策略：用户可自定义的全部行为 */
+export interface DiagnosticsPolicy {
+    /** 检查来源；缺省（或归一化后为空）= 内置 lint + typecheck */
+    checks: DiagnosticsCheck[];
+    /** 编辑后自动诊断（tools/post-execute 登记 → agent/pre-step 收尾注入） */
+    auto: boolean;
+    /** 是否把 run_diagnostics 暴露给模型 */
+    exposeTool: boolean;
+    /** 投递门槛：`error` 只报错误，`warning` 错误与警告都报 */
+    severity: "error" | "warning";
+    /** 自动诊断每个分区最多列出的发现条数 */
+    maxFindingsPerSection: number;
+    /** 自动诊断注入消息的字符上限 */
+    maxMessageChars: number;
+}
+/** 用户适配器入参：命令的原始产物 + 本次目标 */
+export interface DiagnosticsAdapterInput {
+    /** 分区名（check.name） */
+    name: string;
+    stdout: string;
+    stderr: string;
+    /** 超时 / 被信号杀死时为 undefined */
+    exitCode: number | undefined;
+    /** 本次目标文件（绝对路径）；项目级检查为空数组 */
+    files: string[];
+    /** 项目根 */
+    cwd: string;
+}
+/**
+ * 用户适配器出参。
+ * 提供 `diagnostics` 时文本由 AIPanel 统一渲染（保证 severity 门槛与诊断卡片一致）；
+ * 只有需要自定义叙述时才只给 `text`（此时无结构化条目、也不参与 severity 过滤）。
+ */
+export interface DiagnosticsAdapterOutput {
+    text?: string;
+    diagnostics?: AIPanelDiagnosticEntry[];
+}
+export type DiagnosticsAdapter = (input: DiagnosticsAdapterInput) => DiagnosticsAdapterOutput | Promise<DiagnosticsAdapterOutput>;
+/** 命令检查默认超时 */
+export declare const COMMAND_CHECK_TIMEOUT_MS = 60000;
+/**
+ * 可诊断源码扩展名（内置 lint / typecheck 的默认匹配集）。
+ * node 侧的 `JS_EXTENSIONS` 引它，保持单一来源。
+ */
+export declare const SOURCE_EXTENSIONS: readonly string[];
+/**
+ * 目标文件是否命中检查声明的扩展名。
+ * 未声明（undefined / 空）表示不限；实现保持 client-safe（不引 node:path）。
+ */
+export declare function matchesExtensions(filePath: string, extensions: readonly string[] | undefined): boolean;
+/** 内置 linter 目录项：一个预设 = 一条命令检查的全部默认值（纯数据） */
+export interface BuiltinLinterSpec {
+    /** 分区标题 */
+    label: string;
+    /** 项目本地包名（bin 从项目 package.json 解析，解析不到即视为未安装） */
+    package: string;
+    /** bin 名；缺省与包名相同 */
+    bin?: string;
+    /** 默认 argv（可含 `{file}` / `{files}` 占位符） */
+    args: string[];
+    /** 全量诊断时的 argv（含占位符的预设必须给，否则全量时跳过） */
+    projectArgs?: string[];
+    /** 默认匹配的扩展名 */
+    extensions: string[];
+    /** 默认输出适配器（内置工具一律能出结构化诊断，因此卡片/severity 都生效） */
+    format: DiagnosticsFormat;
+}
+/**
+ * 内置 linter 目录（数据表）。加一个常见 lint = 加一行；预设展开后与用户自定义检查同形，
+ * 走同一条执行 + 适配逻辑，所以"内置"与"自定义"没有第二套底层实现。
+ */
+export declare const BUILTIN_LINTERS: {
+    readonly eslint: {
+        readonly label: "ESLint";
+        readonly package: "eslint";
+        readonly args: ["--format", "json", "{files}"];
+        readonly projectArgs: ["--format", "json", "."];
+        readonly extensions: string[];
+        readonly format: "eslint-json";
+    };
+    readonly oxlint: {
+        readonly label: "oxlint";
+        readonly package: "oxlint";
+        readonly args: ["--format=json", "--ignore-pattern", "node_modules", "{files}"];
+        readonly projectArgs: ["--format=json", "--ignore-pattern", "node_modules", "."];
+        readonly extensions: string[];
+        readonly format: "oxlint-json";
+    };
+    readonly stylelint: {
+        readonly label: "Stylelint";
+        readonly package: "stylelint";
+        readonly args: ["--formatter", "json", "{files}"];
+        readonly projectArgs: ["--formatter", "json", "**/*.{css,scss,less}"];
+        readonly extensions: [".css", ".scss", ".less"];
+        readonly format: "stylelint-json";
+    };
+};
+/** 内置 linter 预设 id */
+export type BuiltinLinterId = keyof typeof BUILTIN_LINTERS;
+/** 自动诊断默认分区条数上限（与历史行为一致） */
+export declare const DEFAULT_MAX_FINDINGS_PER_SECTION = 3;
+/** 自动诊断默认注入字符上限（与历史行为一致） */
+export declare const DEFAULT_MAX_MESSAGE_CHARS = 4000;
+/**
+ * 缺省检查来源（= 未配置 diagnostics 时的行为）：
+ * 项目装了哪个内置 linter 就跑哪个（没装的自动跳过），类型检查始终在。
+ */
+export declare const DEFAULT_BUILTIN_CHECKS: readonly DiagnosticsCheck[];
+/** 策略默认值（单一来源：provider 的默认值、插件的兜底都引它） */
+export declare const DEFAULT_DIAGNOSTICS_POLICY: DiagnosticsPolicy;
+/** 是否为命令检查（用户自定义：既无内置 linter 预设也无内置引擎） */
+export declare function isCommandCheck(check: DiagnosticsCheck): check is CommandCheck;
+/** 是否为内置 linter 预设 */
+export declare function isLinterPreset(check: DiagnosticsCheck): check is LinterPresetCheck;
+/** 是否为内置类型检查（引擎级） */
+export declare function isTypecheckCheck(check: DiagnosticsCheck): check is TypecheckCheck;
+/** 该检查是否在指定阶段执行 */
+export declare function checkRunsInPhase(check: DiagnosticsCheck, phase: DiagnosticsPhase): boolean;
+/**
+ * 逐层覆盖 + 逐字段归一化：后面的层覆盖前面的层，非法值回退默认并通过 `onInvalid` 告警。
+ * 调用方（provider）负责把告警写进日志，核心层保持无副作用、可单测。
+ */
+export declare function resolveDiagnosticsPolicy(layers: readonly (Partial<DiagnosticsPolicy> | undefined)[], onInvalid?: (message: string) => void): DiagnosticsPolicy;

package/lib/common/options.d.ts

@@ -86,8 +86,6 @@ export interface PluginOptions<P extends Record<string, unknown> = Record<string
     language?: string;
     /** @deprecated 使用 providerOptions.settings */
     settings?: unknown;
-    /** @deprecated 使用 providerOptions.enableLsp */
-    enableLsp?: boolean;
     /** @deprecated 使用 providerOptions.enablePrettier */
     enablePrettier?: boolean;
 }

package/lib/index.cjs

@@ -15,6 +15,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var lib_exports = {};
 module.exports = __toCommonJS(lib_exports);
 __reExport(lib_exports, require("./common/constants.cjs"), module.exports);
+__reExport(lib_exports, require("./common/diagnostics.cjs"), module.exports);
 __reExport(lib_exports, require("./common/inspector/index.cjs"), module.exports);
 __reExport(lib_exports, require("./common/logger-core.cjs"), module.exports);
 __reExport(lib_exports, require("./common/options.cjs"), module.exports);
@@ -24,6 +25,7 @@ __reExport(lib_exports, require("./common/utils.cjs"), module.exports);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   ...require("./common/constants.cjs"),
+  ...require("./common/diagnostics.cjs"),
   ...require("./common/inspector/index.cjs"),
   ...require("./common/logger-core.cjs"),
   ...require("./common/options.cjs"),

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./common/constants";
+export * from "./common/diagnostics";
 export * from "./common/inspector";
 export * from "./common/logger-core";
 export * from "./common/options";