@aipanel/core 1.3.4 → 1.3.6

package/es/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/es/common/constants.mjs

@@ -130,7 +130,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/es/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/es/common/diagnostics.mjs

@@ -0,0 +1,226 @@
+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;
+}
+export {
+  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/es/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/es/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";

package/es/index.mjs

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

package/es/node/diagnostics.d.ts

@@ -1,8 +1,9 @@
+import { type DiagnosticsPhase, type DiagnosticsPolicy } from "../common/diagnostics";
 /** 是否为可诊断的源码文件（供宿主钩子过滤 edit/write 目标） */
 export declare function isJsFile(filePath: string): boolean;
 /**
  * run_diagnostics 工具描述（单一来源，供 opencode / dsh 两侧插件引用）：
- * 只声明能力与支持的文件类型，不涉及内部使用的检查工具。
+ * 只声明能力与支持的文件类型，不涉及内部使用的检查工具（检查来源由用户配置，可能是项目命令）。
  */
 export declare const DIAGNOSTICS_TOOL_DESCRIPTION: string;
 /** LSP 风格诊断项（供宿主写入 metadata.diagnostics 等结构化输出） */
@@ -33,18 +34,7 @@ export interface TscResult {
 export interface EslintOutput {
     text?: string;
     diagnostics?: DiagnosticItem[];
-    /** 实际运行的 lint 引擎（"ESLint" / "oxlint"）；缺省视为 ESLint（兼容旧调用方） */
-    engines?: string[];
 }
-export interface DiagnosticsResult {
-    eslintOutput: EslintOutput;
-    tscOutput: TscResult;
-}
-/**
- * ESLint 检查，接受文件路径或 glob 模式。
- * 结果按 error / warning 分级格式化；warnings 数量超限时截断并注明。
- */
-export declare function lintFiles(pattern: string, cwd: string, warnLimit?: number): Promise<EslintOutput>;
 /** 从文件路径向上查找最近的 tsconfig.json 所在目录 */
 export declare function findTsconfigDir(filePath: string): string | null;
 /** 在工作区子目录中查找 tsconfig.json（不包括根目录；调用方已处理根目录场景） */
@@ -58,34 +48,62 @@ export declare function runTypeCheck(filePath: string | undefined, cwd: string):
  * 一次编辑批次里的 N 个文件因此从 N 次项目构建降到 1 次。
  */
 export declare function runTypeChecksForFiles(files: string[], cwd: string): Promise<Map<string, TscResult>>;
-/** 并行运行 ESLint + 类型检查（单文件或 glob） */
-export declare function runAllChecks(pattern: string, cwd: string): Promise<DiagnosticsResult>;
-/**
- * 批量运行 ESLint + 类型检查：Lint 逐文件（ESLint 进程内、oxlint 单次 CLI），
- * 类型检查按 tsconfig 项目合并为一次（见 runTypeChecksForFiles）。
- * 返回"文件绝对路径 → 诊断结果"，供 step 边界的一次性收尾诊断使用。
- */
-export declare function runAllChecksForFiles(files: string[], cwd: string): Promise<Map<string, DiagnosticsResult>>;
-/**
- * 全量项目诊断：优先从根 tsconfig 运行一次类型检查 --build，
- * 根无 tsconfig 时回退到逐个子目录 build；ESLint 以 "." 全量扫描。
- */
-export declare function runProjectDiagnostics(workspace: string): Promise<DiagnosticsResult>;
+/** 诊断分区：一个检查在一段目标上的产出 */
+export interface DiagnosticsSection {
+    /** 分区标题：check 的 name，或内置引擎标题（ESLint + oxlint / vue-tsc） */
+    name: string;
+    /** 所属目标文件（相对项目根）；仅编辑后自动诊断按文件拆分时存在 */
+    target?: string;
+    /** 模型可见正文；无内容时缺省（自动诊断据此跳过该分区） */
+    text?: string;
+    /** LSP 坐标结构化条目（0-based），供 canonical 输出与诊断卡片使用 */
+    diagnostics: DiagnosticItem[];
+}
+/** 诊断结果：有序分区列表（历史上是写死的 { eslintOutput, tscOutput }，现已泛化） */
+export interface DiagnosticsResult {
+    sections: DiagnosticsSection[];
+}
+/** 诊断目标：agent 调工具（单文件 / 全量）或编辑后自动诊断（本步编辑过的文件） */
+export type DiagnosticsTarget = {
+    kind: "file";
+    file: string;
+    cwd: string;
+} | {
+    kind: "project";
+    cwd: string;
+} | {
+    kind: "edited";
+    files: string[];
+    cwd: string;
+};
+/** 渲染选项 */
+export interface RenderDiagnosticsOptions {
+    /** 只输出有发现的分区（编辑后自动诊断；全空返回空串） */
+    onlyFindings?: boolean;
+    /** 每个分区的发现条数上限（超出折叠成一行提示） */
+    maxFindingsPerSection?: number;
+}
+/** 类型检查分区标题（单一来源：跟随实际引擎 tsc / vue-tsc） */
 /** 类型检查分区标题（单一来源：跟随实际引擎 tsc / vue-tsc） */
 export declare function tscSectionTitle(tscOutput: TscResult): string;
-/** Lint 分区标题（单一来源：跟随实际运行的引擎组合，如 "ESLint + oxlint"） */
-export declare function lintSectionTitle(lintOutput: EslintOutput): string;
 /** 分区发现被条数上限折叠时的提示（自动诊断摘要与 run_diagnostics 完整输出的分界） */
 export declare function omittedFindingsHint(omitted: number): string;
 /**
- * 组装统一的分区诊断文本（Lint / 类型检查）。
- * 默认保留空分区的占位文案（run_diagnostics 要正面回答"有没有问题"）；
+ * 诊断深入口：按策略与阶段执行配置的检查，返回有序分区。
+ *
+ * 三类检查：`typecheck`（引擎级内置）、内置 linter 预设（展开成 CommandCheck）、
+ * 用户自定义检查——后两类走**完全同一条**执行与适配逻辑。
+ * 检查按声明顺序串行执行，输出顺序确定、进程数可控；
+ * `severity` 门槛在分区归一化处生效，文本与结构化条目一起收紧。
+ */
+export declare function runDiagnostics(target: DiagnosticsTarget, policy: DiagnosticsPolicy, phase: DiagnosticsPhase): Promise<DiagnosticsResult>;
+/** 汇总结构化条目（canonical 输出 / 诊断卡片用） */
+export declare function collectDiagnostics(result: DiagnosticsResult): DiagnosticItem[];
+/**
+ * 把分区结果渲染成模型可见文本。
  * `onlyFindings: true` 只输出有发现的分区、全空返回空串（编辑后自动诊断不刷占位噪音）；
  * `maxFindingsPerSection` 把每个分区的发现折叠成有界摘要——编辑后自动诊断每个 step 都会投递，
  * 因此用条数上限控制重复成本，完整结果仍由不带上限的 run_diagnostics 给出。
- * `title` 允许为空串，此时直接返回分区正文（追加式投递场景无需标题）。
+ * 编辑后自动诊断（分区带 target）保留 `### 文件` 结构。
  */
-export declare function formatDiagnosticsSections(title: string, eslintOutput: EslintOutput, tscOutput: TscResult, options?: {
-    onlyFindings?: boolean;
-    maxFindingsPerSection?: number;
-}): string;
+export declare function renderDiagnostics(result: DiagnosticsResult, options?: RenderDiagnosticsOptions): string;