@aipanel/dsh-plugin 1.2.21 → 1.2.22

package/dist/index.js

@@ -306,10 +306,10 @@ function isJsFile(filePath) {
   return JS_EXTENSIONS.has(path.extname(filePath));
 }
 var DIAGNOSTICS_TOOL_DESCRIPTION = [
-  "\u8FD0\u884C ESLint \u4E0E TypeScript \u7C7B\u578B\u8BCA\u65AD\uFF0C\u8FD4\u56DE\u8BCA\u65AD\u7ED3\u679C\u3002",
+  "\u8FD0\u884C Lint\uFF08ESLint / oxlint\uFF09\u4E0E TypeScript \u7C7B\u578B\u8BCA\u65AD\uFF0C\u8FD4\u56DE\u8BCA\u65AD\u7ED3\u679C\u3002",
   "",
   "**\u652F\u6301\u7684\u6587\u4EF6\u7C7B\u578B**\uFF1A",
-  `- ESLint\uFF1AJavaScript / TypeScript / Vue \u6E90\u7801\uFF08${[...JS_EXTENSIONS].map((e) => `*${e}`).join(" ")}\uFF09`,
+  `- 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`,
   "- TypeScript \u7C7B\u578B\u68C0\u67E5\uFF1A*.ts *.tsx *.vue",
   "",
   "**\u4F55\u65F6\u4F7F\u7528\u6B64\u5DE5\u5177**\uFF1A",
@@ -333,12 +333,68 @@ function loadESLint(workspace) {
 }
 async function lintFiles(pattern, cwd, warnLimit = 5) {
   loadESLint(cwd);
-  if (!ESLintClass) {
+  const [eslintOutput, oxlintOutput] = await Promise.all([
+    ESLintClass ? runEslintFiles(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: `[ESLint] \u672A\u8FD0\u884C\uFF1A\u65E0\u6CD5\u5728 workspace "${cwd}" \u89E3\u6790\u5230 eslint\uFF08\u4EC5\u663E\u793A TypeScript \u8BCA\u65AD\uFF09`,
+      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] };
+  const ESLINT_ERROR = 2;
+  const ESLINT_WARN = 1;
+  const lines = [];
+  const errors = messages.filter((m) => m.severity === ESLINT_ERROR);
+  const warnings = messages.filter((m) => m.severity === ESLINT_WARN);
+  if (errors.length > 0) {
+    lines.push(
+      ...errors.map(
+        (m) => `ERROR [${m.filePath}:${m.line}:${m.column}] ${m.message} (${m.ruleId})`
+      )
+    );
+  }
+  if (warnings.length > 0) {
+    lines.push(
+      ...warnings.slice(0, warnLimit).map((m) => `WARN [${m.filePath}:${m.line}:${m.column}] ${m.message} (${m.ruleId})`)
+    );
+    if (warnings.length > warnLimit)
+      lines.push(`... and ${warnings.length - warnLimit} more warnings`);
+  }
+  const diagnostics = messages.map((m) => ({
+    severity: m.severity === ESLINT_ERROR ? SEVERITY_ERROR : m.severity === ESLINT_WARN ? SEVERITY_WARN : m.severity,
+    file: m.filePath,
+    range: {
+      start: { line: (m.line || 1) - 1, character: (m.column || 1) - 1 },
+      end: {
+        line: (m.endLine || m.line || 1) - 1,
+        character: (m.endColumn || m.column || 1) - 1
+      }
+    },
+    message: `[${engine.label}] ${m.message} (${m.ruleId})`,
+    source: engine.source
+  }));
+  return {
+    text: lines.length > 0 ? lines.join("\n") : void 0,
+    diagnostics,
+    engines: [engine.label]
+  };
+}
+async function runEslintFiles(pattern, cwd, warnLimit) {
   try {
     const eslint = new ESLintClass({ cwd });
     const results = await eslint.lintFiles(pattern);
@@ -350,48 +406,111 @@ async function lintFiles(pattern, cwd, warnLimit = 5) {
       fileCount: results.length,
       messageCount: messages.length
     });
-    if (messages.length === 0) return {};
-    const ESLINT_ERROR = 2;
-    const ESLINT_WARN = 1;
-    const lines = [];
-    const errors = messages.filter((m) => m.severity === ESLINT_ERROR);
-    const warnings = messages.filter((m) => m.severity === ESLINT_WARN);
-    if (errors.length > 0) {
-      lines.push(
-        ...errors.map(
-          (m) => `ERROR [${m.filePath}:${m.line}:${m.column}] ${m.message} (${m.ruleId})`
-        )
-      );
-    }
-    if (warnings.length > 0) {
-      lines.push(
-        ...warnings.slice(0, warnLimit).map((m) => `WARN [${m.filePath}:${m.line}:${m.column}] ${m.message} (${m.ruleId})`)
-      );
-      if (warnings.length > warnLimit)
-        lines.push(`... and ${warnings.length - warnLimit} more warnings`);
-    }
-    const diagnostics = messages.map((m) => ({
-      severity: m.severity === ESLINT_ERROR ? SEVERITY_ERROR : m.severity === ESLINT_WARN ? SEVERITY_WARN : m.severity,
-      file: m.filePath,
-      range: {
-        start: { line: (m.line || 1) - 1, character: (m.column || 1) - 1 },
-        end: {
-          line: (m.endLine || m.line || 1) - 1,
-          character: (m.endColumn || m.column || 1) - 1
-        }
-      },
-      message: `[ESLint] ${m.message} (${m.ruleId})`,
-      source: "eslint"
-    }));
-    return { text: lines.length > 0 ? lines.join("\n") : void 0, diagnostics };
+    return formatLintMessages(messages, { label: "ESLint", source: "eslint" }, warnLimit);
   } catch (err) {
     log2.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: []
+      diagnostics: [],
+      engines: ["ESLint"]
     };
   }
 }
+var _oxlintBin;
+function resolveOxlintBin(workspace) {
+  if (_oxlintBin !== void 0) return _oxlintBin;
+  try {
+    const req = createRequire(path.join(workspace, "package.json"));
+    const pkgJsonPath = req.resolve("oxlint/package.json");
+    const pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+    const binRel = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.oxlint;
+    _oxlintBin = binRel ? path.join(path.dirname(pkgJsonPath), binRel) : null;
+  } catch {
+    _oxlintBin = null;
+  }
+  return _oxlintBin;
+}
+function oxlintRuleName(code) {
+  if (!code) return null;
+  const match = /\(([^)]*)\)$/.exec(code);
+  return match ? match[1] : code;
+}
+function parseOxlintOutput(stdout, cwd) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    const start = stdout.indexOf("{");
+    const end = stdout.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      try {
+        parsed = JSON.parse(stdout.slice(start, end + 1));
+      } catch {
+        parsed = void 0;
+      }
+    }
+  }
+  if (!parsed) throw new Error("\u65E0\u6CD5\u89E3\u6790 oxlint JSON \u8F93\u51FA");
+  return (parsed.diagnostics ?? []).flatMap((d) => {
+    const filePath = d.filename ? path.isAbsolute(d.filename) ? d.filename : path.resolve(cwd, d.filename) : "";
+    if (!filePath) return [];
+    const span = d.labels?.[0]?.span;
+    const line = span?.line ?? 1;
+    const column = span?.column ?? 1;
+    return [
+      {
+        // oxlint 无 endLine/endColumn，同行按 span.length 延伸近似
+        severity: d.severity === "error" ? 2 : 1,
+        line,
+        column,
+        endLine: line,
+        endColumn: column + (span?.length ?? 0),
+        message: d.message ?? "\u672A\u77E5\u8BCA\u65AD",
+        ruleId: oxlintRuleName(d.code),
+        filePath
+      }
+    ];
+  });
+}
+async function runOxlintFiles(pattern, cwd, warnLimit) {
+  const bin = resolveOxlintBin(cwd);
+  if (!bin) return {};
+  return new Promise((resolve) => {
+    exec(
+      // 与 ESLint 默认行为对齐：忽略 node_modules（oxlint 默认不排除）
+      `node "${bin}" --format=json --ignore-pattern node_modules "${pattern}"`,
+      { cwd, timeout: 6e4, maxBuffer: 50 * 1024 * 1024 },
+      (error, stdout, stderr) => {
+        const killed = error?.killed;
+        if (killed) {
+          log2.warn("oxlint timed out", { pattern });
+          resolve({
+            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"]
+          });
+          return;
+        }
+        try {
+          const messages = parseOxlintOutput(stdout, cwd);
+          log2.debug("oxlint lint", {
+            pattern,
+            messageCount: messages.length,
+            stderr: stderr || void 0
+          });
+          resolve(formatLintMessages(messages, { label: "oxlint", source: "oxlint" }, warnLimit));
+        } catch (e) {
+          log2.warn("oxlint failed", { pattern, error: e.message });
+          resolve({
+            text: `[oxlint] \u8FD0\u884C\u5931\u8D25\uFF1A${e.message}`,
+            diagnostics: [],
+            engines: ["oxlint"]
+          });
+        }
+      }
+    );
+  });
+}
 var _vueTscBin;
 function resolveVueTscBin() {
   if (_vueTscBin !== void 0) return _vueTscBin;
@@ -403,6 +522,46 @@ function resolveVueTscBin() {
   }
   return _vueTscBin;
 }
+var _tscBinByPkgDir = /* @__PURE__ */ new Map();
+function nearestPackageJsonDir(startDir) {
+  let dir = path.resolve(startDir);
+  while (true) {
+    if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+function isVuePackage(pkgDir) {
+  try {
+    const pkg = JSON.parse(fs.readFileSync(path.join(pkgDir, "package.json"), "utf8"));
+    const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+    return "vue" in deps || "nuxt" in deps;
+  } catch {
+    return false;
+  }
+}
+function resolveTypeCheckBin(projectDir) {
+  const pkgDir = nearestPackageJsonDir(projectDir);
+  if (!pkgDir || isVuePackage(pkgDir)) {
+    const bin2 = resolveVueTscBin();
+    return bin2 ? { bin: bin2, source: "vue-tsc" } : null;
+  }
+  let bin = _tscBinByPkgDir.get(pkgDir);
+  if (bin === void 0) {
+    try {
+      const req = createRequire(path.join(pkgDir, "package.json"));
+      bin = req.resolve("typescript/bin/tsc");
+    } catch {
+      bin = null;
+    }
+    _tscBinByPkgDir.set(pkgDir, bin);
+    if (!bin) log2.debug("workspace tsc not resolvable, fallback to vue-tsc", { pkgDir });
+  }
+  if (bin) return { bin, source: "tsc" };
+  const vueBin = resolveVueTscBin();
+  return vueBin ? { bin: vueBin, source: "vue-tsc" } : null;
+}
 function findTsconfigDir(filePath) {
   const resolved = path.resolve(filePath);
   let dir = path.dirname(resolved);
@@ -448,7 +607,7 @@ function findAllTsconfigDirs(workspace) {
   });
   return dirs;
 }
-function parseTscDiags(rawOutput, filePath, projectDir) {
+function parseTscDiags(rawOutput, filePath, projectDir, source = "tsc") {
   const errorLinePat = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+TS(\d+):\s+(.+)$/;
   const diags = [];
   const resolved = filePath ? path.resolve(filePath) : void 0;
@@ -469,40 +628,40 @@ function parseTscDiags(rawOutput, filePath, projectDir) {
           end: { line: Number(lineNum) - 1, character: Number(col) - 1 }
         },
         message: `[TS${code}] ${message}`,
-        source: "vue-tsc"
+        source
       });
     }
   }
   return diags;
 }
-async function runVueTsc(filePath, cwd) {
+async function runTypeCheck(filePath, cwd) {
   const dir = cwd;
   const projectDir = filePath ? findTsconfigDir(filePath) ?? dir : dir;
-  log2.debug("runVueTsc", {
+  log2.debug("runTypeCheck", {
     filePath: filePath || "(all)",
     cwd: dir,
     projectDir,
     processCwd: process.cwd()
   });
-  const bin = resolveVueTscBin();
-  if (!bin) {
-    log2.warn("vue-tsc bin not found", { projectDir });
+  const engine = resolveTypeCheckBin(projectDir);
+  if (!engine) {
+    log2.warn("type-check bin not found", { projectDir });
     return { rawOutput: "", exitCode: 0 };
   }
   const timeout = filePath ? 6e4 : 12e4;
   const maxBuffer = filePath ? 10 * 1024 * 1024 : 50 * 1024 * 1024;
   return new Promise((resolve) => {
     exec(
-      `node "${bin}" --build --noEmit --pretty false`,
+      `node "${engine.bin}" --build --noEmit --pretty false`,
       { cwd: projectDir, timeout, maxBuffer },
       (error, stdout, stderr) => {
         let rawOutput = stdout + stderr;
         const killed = error?.killed;
         const exitCode = typeof error?.code === "number" ? error.code : killed ? 1 : 0;
         if (killed && !rawOutput) {
-          rawOutput = "vue-tsc \u68C0\u67E5\u8D85\u65F6\uFF0C\u8BF7\u5C1D\u8BD5\u7F29\u5C0F\u68C0\u67E5\u8303\u56F4\u6216\u4F18\u5316\u9879\u76EE\u914D\u7F6E\u3002";
+          rawOutput = `${engine.source} \u68C0\u67E5\u8D85\u65F6\uFF0C\u8BF7\u5C1D\u8BD5\u7F29\u5C0F\u68C0\u67E5\u8303\u56F4\u6216\u4F18\u5316\u9879\u76EE\u914D\u7F6E\u3002`;
         }
-        const diagnostics = parseTscDiags(rawOutput, filePath, projectDir);
+        const diagnostics = parseTscDiags(rawOutput, filePath, projectDir, engine.source);
         if (filePath) {
           const resolved = path.resolve(filePath);
           const errorLinePat = /^(.+?)\((\d+),(\d+)\):\s+(error|warning)\s+TS\d+:/;
@@ -520,12 +679,13 @@ async function runVueTsc(filePath, cwd) {
           }
           rawOutput = filtered.join("\n");
         }
-        log2.debug("vue-tsc finished", {
+        log2.debug("type-check finished", {
+          engine: engine.source,
           filePath: filePath || "(all)",
           exitCode,
           outputLength: rawOutput.length
         });
-        resolve({ rawOutput, exitCode, diagnostics });
+        resolve({ rawOutput, exitCode, diagnostics, source: engine.source });
       }
     );
   });
@@ -534,7 +694,7 @@ async function runAllChecks(pattern, cwd) {
   log2.debug("runAllChecks", { pattern, cwd });
   const [eslintOutput, tscOutput] = await Promise.all([
     lintFiles(pattern, cwd),
-    runVueTsc(pattern, cwd)
+    runTypeCheck(pattern, cwd)
   ]);
   return { eslintOutput, tscOutput };
 }
@@ -543,20 +703,31 @@ async function runProjectDiagnostics(workspace) {
   log2.debug("Tsc dirs to check", { count: tscDirs.length, dirs: tscDirs });
   const [eslintOutput, ...tscOutputs] = await Promise.all([
     lintFiles(".", workspace, 10),
-    ...tscDirs.map((dir) => runVueTsc(void 0, dir))
+    ...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 ?? [])
+    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 formatDiagnosticsSections(title, eslintOutput, tscOutput) {
   const parts = [];
-  parts.push("## ESLint\n\n" + (eslintOutput.text || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898"));
+  parts.push(`## ${lintSectionTitle(eslintOutput)}
+
+` + (eslintOutput.text || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898"));
   const tscLines = tscOutput.rawOutput.trim();
-  parts.push("## vue-tsc\n\n" + (tscLines || "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF"));
+  parts.push(`## ${tscSectionTitle(tscOutput)}
+
+` + (tscLines || "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF"));
   return `${title}
 
 ` + parts.join("\n\n");
@@ -870,8 +1041,8 @@ function buildDiagnosticsCanonical(title, eslintOutput, tscOutput) {
   return {
     title,
     sections: [
-      { title: "ESLint", text: eslintOutput.text || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898" },
-      { title: "vue-tsc", text: tscOutput.rawOutput.trim() || "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF" }
+      { title: lintSectionTitle(eslintOutput), text: eslintOutput.text || "\u6CA1\u6709\u53D1\u73B0\u95EE\u9898" },
+      { title: tscSectionTitle(tscOutput), text: tscOutput.rawOutput.trim() || "\u6CA1\u6709\u53D1\u73B0\u7C7B\u578B\u9519\u8BEF" }
     ],
     diagnostics: [
       ...toDiagnosticEntries(eslintOutput.diagnostics ?? []),
@@ -1074,8 +1245,14 @@ function apply(ctx, config = {}) {
           tscOutput: { rawOutput: "", exitCode: 0 }
         }));
         const parts = [];
-        if (tscOutput.rawOutput.trim()) parts.push("## vue-tsc\n\n" + tscOutput.rawOutput.trim());
-        if (eslintOutput.text) parts.push("## ESLint\n\n" + eslintOutput.text);
+        if (tscOutput.rawOutput.trim())
+          parts.push(`## ${tscSectionTitle(tscOutput)}
+
+` + tscOutput.rawOutput.trim());
+        if (eslintOutput.text)
+          parts.push(`## ${lintSectionTitle(eslintOutput)}
+
+` + eslintOutput.text);
         const diagText = parts.join("\n\n");
         if (!diagText) return decision;
         const existing = decision.kind === "accept" && decision.content || result.content;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aipanel/dsh-plugin",
-  "version": "1.2.21",
+  "version": "1.2.22",
   "type": "module",
   "description": "AIPanel for DeepSeek Harness (dsh)：注入审查工具 run_diagnostics、编辑后自动诊断。",
   "main": "./dist/index.js",
@@ -25,7 +25,7 @@
     "@deepseek-ai/dsh-user-questions": "^0.1.5-rc.1",
     "@deepseek-ai/dsh-util-values": "^0.1.5-rc.1",
     "esbuild": "^0.25.0",
-    "@aipanel/core": "1.2.21"
+    "@aipanel/core": "1.2.22"
   },
   "scripts": {
     "build": "esbuild src/index.ts --bundle --outfile=dist/index.js --platform=node --format=esm --target=node18 --external:@deepseek-ai/* --external:node:* --external:vue-tsc",