@duckmind/dm-darwin-x64 0.66.5 → 0.66.6

package/extensions/dm-lens/dist/clients/dispatch/runners/mypy.js

@@ -0,0 +1,70 @@
+import * as path from "node:path";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { hasMypyConfig } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
+const mypy = createAvailabilityChecker("mypy", "");
+const MYPY_EXIT_CODES = { ran: [1, 2] };
+export function parseMypyOutput(raw, fallbackPath, cwd) {
+  const diagnostics = [];
+  const linePattern = /^(.+?):(\d+)(?::(\d+))?:\s*(error|warning|note):\s*(.+?)(?:\s+\[([^\]]+)\])?$/gm;
+  for (const match of raw.matchAll(linePattern)) {
+    const [, file, lineNum, col, level, message, errorCode] = match;
+    if (!lineNum || !level || !message)
+      continue;
+    if (level === "note")
+      continue;
+    const severity = level === "error" ? "error" : "warning";
+    const rule = errorCode ?? "mypy";
+    const filePath = file && file.trim() ? path.isAbsolute(file) ? file : path.resolve(cwd, file) : fallbackPath;
+    diagnostics.push({
+      id: `mypy-${lineNum}-${rule}`,
+      message: errorCode ? `[${errorCode}] ${message}` : message,
+      filePath,
+      line: Number(lineNum),
+      column: col ? Number(col) : 1,
+      severity,
+      semantic: severity === "error" ? "blocking" : "warning",
+      tool: "mypy",
+      rule,
+      defectClass: "correctness"
+    });
+  }
+  return diagnostics;
+}
+const mypyRunner = {
+  id: "mypy",
+  appliesTo: ["python"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "mypy");
+    if (!hasMypyConfig(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let cmd = null;
+    if (await mypy.isAvailableAsync(cwd)) {
+      cmd = mypy.getCommand(cwd);
+    } else {
+      cmd = await resolveToolCommandWithInstallFallback(cwd, "mypy");
+    }
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const result = await safeSpawnAsync(cmd, ["--no-error-summary", "--show-column-numbers", ctx.filePath], { timeout: 30000, cwd });
+    const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
+    const run = parseToolRun("mypy", { result, output: result.stdout, exitCodes: MYPY_EXIT_CODES }, (out) => parseMypyOutput(out, ctx.filePath, cwd), { parseOutput: raw });
+    if (run.skipped)
+      return run.skipped;
+    const diagnostics = run.diagnostics;
+    return finishParsedRun({
+      tool: "mypy",
+      ctx,
+      result,
+      diagnostics
+    });
+  }
+};
+export default mypyRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/oxlint.js

@@ -0,0 +1,305 @@
+import * as path from "node:path";
+import { findLocalBinUpwards, localBinPath } from "../../package-manager.js";
+import { pathsEqual } from "../../path-utils.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { truncatedByOutputCap } from "../../spawn-output-cap.js";
+import { getJstsLintPolicyForCwd, hasVitePlusConfig } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { resolveToolCommand, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+const MAX_OXLINT_OUTPUT_BYTES = 8 * 1024 * 1024;
+const OXLINT_NO_FILES = Symbol("oxlint-no-files");
+const OXLINT_NO_FILES_UNCONFIRMED = Symbol("oxlint-no-files-unconfirmed");
+const OXLINT_NO_FILES_BANNER = "No files found to lint. Please check your paths and ignore patterns.";
+const OXLINT_NO_FILES_REPORT_KEYS = new Set([
+  "diagnostics",
+  "number_of_files",
+  "number_of_rules",
+  "threads_count",
+  "start_time"
+]);
+function resolveLocalVp(cwd) {
+  return localBinPath(findLocalBinUpwards("vp", cwd)) ?? null;
+}
+async function resolveVitePlusCommand(cwd) {
+  const local = resolveLocalVp(cwd);
+  if (local)
+    return local;
+  const version = await safeSpawnAsync("vp", ["--version"], {
+    timeout: 5000,
+    cwd
+  });
+  return !version.error && version.status === 0 ? "vp" : null;
+}
+const oxlintRunner = {
+  id: "oxlint",
+  appliesTo: ["jsts"],
+  priority: PRIORITY.LINT_SECONDARY,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "oxlint");
+    const policy = getJstsLintPolicyForCwd(cwd);
+    if (!policy.preferredRunners.includes("oxlint")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let cmd = null;
+    let args;
+    if (hasVitePlusConfig(cwd)) {
+      cmd = await resolveVitePlusCommand(cwd);
+    }
+    if (cmd) {
+      args = ["lint", "--format", "json", ctx.filePath];
+    } else {
+      const oxlintCmd = resolveToolCommand(cwd, "oxlint") ?? "oxlint";
+      cmd = await ctx.hasTool(oxlintCmd) ? oxlintCmd : await resolveToolCommandWithInstallFallback(cwd, "oxlint");
+      args = ["--format", "json", ctx.filePath];
+    }
+    if (!cmd) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const result = await safeSpawnAsync(cmd, args, {
+      cwd,
+      timeout: 30000,
+      maxOutputBytes: MAX_OXLINT_OUTPUT_BYTES
+    });
+    const stdout = result.stdout ?? "";
+    const stderr = result.stderr ?? "";
+    const parsedOutput = stdout + stderr;
+    const noFilesDecision = decideOxlintNoFiles(result, stdout, stderr);
+    const parsedRun = parseToolRun("oxlint", {
+      result,
+      output: parsedOutput,
+      exitCodes: { ran: [1, 2] }
+    }, () => {
+      if (noFilesDecision.kind === "expected-no-files") {
+        return [OXLINT_NO_FILES];
+      }
+      if (noFilesDecision.kind === "unconfirmed-no-files" && result.status === 0) {
+        return [OXLINT_NO_FILES_UNCONFIRMED];
+      }
+      let parsed = parseOxlintJson(stdout, ctx.filePath, cwd);
+      if (parsed.length === 0 && stdout.length > 0) {
+        parsed = parseOxlintUnix(parsedOutput, ctx.filePath, cwd);
+      }
+      return parsed;
+    }, { parseOutput: parsedOutput });
+    if (parsedRun.skipped)
+      return parsedRun.skipped;
+    if (parsedRun.diagnostics.includes(OXLINT_NO_FILES)) {
+      return {
+        status: "skipped",
+        diagnostics: [],
+        semantic: "none",
+        skipReason: "no-files-matched"
+      };
+    }
+    if (parsedRun.diagnostics.includes(OXLINT_NO_FILES_UNCONFIRMED)) {
+      const reason = noFilesDecision.kind === "unconfirmed-no-files" ? noFilesDecision.reason : "status-zero";
+      return {
+        status: "failed",
+        diagnostics: [
+          {
+            id: `oxlint:no-files-unconfirmed:${reason}`,
+            message: `oxlint no-files report was not canonical (${reason})`,
+            filePath: ctx.filePath,
+            line: 1,
+            column: 1,
+            severity: "warning",
+            semantic: "warning",
+            tool: "oxlint"
+          }
+        ],
+        semantic: "warning",
+        failureKind: "unconfirmed_output",
+        failureMessage: `no-files-${reason}`
+      };
+    }
+    const diagnostics = parsedRun.diagnostics.filter((diagnostic) => diagnostic !== OXLINT_NO_FILES && diagnostic !== OXLINT_NO_FILES_UNCONFIRMED);
+    return finishParsedRun({
+      tool: "oxlint",
+      ctx,
+      result,
+      diagnostics,
+      classify: (diagnostics) => {
+        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
+        return {
+          status: !hasBlocking && result.status === 0 ? "succeeded" : "failed",
+          semantic: hasBlocking ? "blocking" : "warning"
+        };
+      }
+    });
+  }
+};
+function oxlintProcessState(result) {
+  const failureKind = result.spawnFailure?.kind;
+  if (truncatedByOutputCap(result))
+    return "truncated";
+  if (result.failure === "timeout" || failureKind === "timeout")
+    return "timeout";
+  if (result.failure === "aborted" || failureKind === "killed")
+    return "killed";
+  if (result.signal || result.failure === "signal")
+    return "signal";
+  if (result.failure === "spawn" || result.error)
+    return "spawn";
+  return "normal";
+}
+function isNonnegativeInteger(value) {
+  return Number.isInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+  return Number.isInteger(value) && value >= 1;
+}
+function isNonnegativeFinite(value) {
+  return typeof value === "number" && Number.isFinite(value) && value >= 0;
+}
+export function decideOxlintNoFiles(result, stdout, stderr) {
+  const processState = oxlintProcessState(result);
+  if (processState !== "normal") {
+    return {
+      kind: "unconfirmed-no-files",
+      reason: `process-${processState}`
+    };
+  }
+  const jsonStart = stdout.indexOf("{");
+  const bannerText = (jsonStart === -1 ? stdout : stdout.slice(0, jsonStart)).trim();
+  const banner = bannerText === OXLINT_NO_FILES_BANNER ? "exact" : /no files found.+lint/i.test(bannerText) ? "near" : "missing";
+  let report;
+  let jsonMalformed = jsonStart === -1;
+  if (jsonStart !== -1) {
+    try {
+      const parsed = JSON.parse(stdout.slice(jsonStart));
+      if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+        report = parsed;
+      } else {
+        jsonMalformed = true;
+      }
+    } catch {
+      jsonMalformed = true;
+    }
+  }
+  const hasFileCount = report !== undefined && Object.prototype.hasOwnProperty.call(report, "number_of_files");
+  const fileCount = report?.number_of_files;
+  const hasNoFilesEvidence = banner !== "missing" || hasFileCount && (fileCount === 0 || !isNonnegativeInteger(fileCount));
+  if (!hasNoFilesEvidence)
+    return { kind: "ordinary-report" };
+  if (result.status == null) {
+    return { kind: "unconfirmed-no-files", reason: "status-null" };
+  }
+  if (result.status === 0) {
+    return { kind: "unconfirmed-no-files", reason: "status-zero" };
+  }
+  if (result.status !== 1) {
+    return { kind: "unconfirmed-no-files", reason: "status-other" };
+  }
+  if (stderr.trim().length > 0) {
+    return { kind: "unconfirmed-no-files", reason: "stderr-nonempty" };
+  }
+  if (banner === "near") {
+    return { kind: "unconfirmed-no-files", reason: "banner-near" };
+  }
+  if (banner === "missing") {
+    return { kind: "unconfirmed-no-files", reason: "banner-missing" };
+  }
+  if (jsonMalformed || !report) {
+    return { kind: "unconfirmed-no-files", reason: "json-malformed" };
+  }
+  const keys = Object.keys(report);
+  if (keys.some((key) => !OXLINT_NO_FILES_REPORT_KEYS.has(key))) {
+    return { kind: "unconfirmed-no-files", reason: "json-unknown-key" };
+  }
+  if (OXLINT_NO_FILES_REPORT_KEYS.size !== keys.length || [...OXLINT_NO_FILES_REPORT_KEYS].some((key) => !Object.prototype.hasOwnProperty.call(report, key))) {
+    return { kind: "unconfirmed-no-files", reason: "json-missing-key" };
+  }
+  if (!Array.isArray(report.diagnostics) || !isNonnegativeInteger(report.number_of_files) || !isNonnegativeInteger(report.number_of_rules) || !isPositiveInteger(report.threads_count) || !isNonnegativeFinite(report.start_time)) {
+    return {
+      kind: "unconfirmed-no-files",
+      reason: "json-known-field-invalid"
+    };
+  }
+  if (report.diagnostics.length > 0) {
+    return { kind: "unconfirmed-no-files", reason: "diagnostics-nonempty" };
+  }
+  if (report.number_of_files !== 0) {
+    return { kind: "unconfirmed-no-files", reason: "files-nonzero" };
+  }
+  return { kind: "expected-no-files" };
+}
+function extractOxlintRule(code) {
+  if (!code)
+    return "unknown";
+  const open = code.indexOf("(");
+  if (open === -1)
+    return code;
+  const close = code.indexOf(")", open + 1);
+  if (close === -1 || close === open + 1)
+    return code;
+  return code.slice(open + 1, close);
+}
+function parseOxlintJson(raw, filePath, cwd) {
+  const trimmed = raw.trim();
+  if (!trimmed.startsWith("{"))
+    return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return [];
+  }
+  if (!Array.isArray(parsed.diagnostics))
+    return [];
+  const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
+  for (const d of parsed.diagnostics) {
+    if (!d.filename || !pathsEqual(path.resolve(cwd, d.filename), absTarget)) {
+      continue;
+    }
+    const rule = extractOxlintRule(d.code);
+    const label = d.labels?.[0]?.span;
+    const lineNum = label?.line ?? 1;
+    const colNum = label?.column ?? 1;
+    const severity = d.severity === "error" ? "error" : "warning";
+    const help = d.help?.trim();
+    diagnostics.push({
+      id: `oxlint-${rule}-${lineNum}`,
+      message: `${d.message ?? "oxlint issue"} (${rule})`,
+      filePath,
+      line: lineNum,
+      column: colNum,
+      severity,
+      semantic: severity === "error" ? "blocking" : "warning",
+      tool: "oxlint",
+      rule,
+      fixSuggestion: help && help.length > 0 ? help : undefined
+    });
+  }
+  return diagnostics;
+}
+function parseOxlintUnix(raw, filePath, cwd) {
+  const diagnostics = [];
+  const absTarget = path.resolve(cwd, filePath);
+  for (const line of raw.split(`
+`)) {
+    const match = line.match(/^(.+):(\d+):(\d+):\s*(.+?)\s*\(([^)]+)\)$/);
+    if (match) {
+      const [, reportedPath, lineStr, _col, message, rule] = match;
+      if (!reportedPath || !lineStr || !message || !rule)
+        continue;
+      if (!pathsEqual(path.resolve(cwd, reportedPath), absTarget))
+        continue;
+      diagnostics.push({
+        id: `oxlint-${rule}-${lineStr}`,
+        message: `${message} (${rule})`,
+        filePath,
+        line: parseInt(lineStr, 10),
+        severity: "warning",
+        semantic: "warning",
+        tool: "oxlint",
+        rule
+      });
+    }
+  }
+  return diagnostics;
+}
+export default oxlintRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/php-lint.js

@@ -0,0 +1,66 @@
+import * as path from "node:path";
+import { pathsEqual } from "../../path-utils.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveAdoptedRootCommand } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+const PHP_LINT_EXIT_CODES = { ran: [1, 255] };
+const php = createAvailabilityChecker("php", ".exe");
+function parsePhpLintOutput(raw, filePath, cwd) {
+  const output = raw.trim();
+  if (!output || !/(?:PHP )?Parse error:/i.test(output))
+    return [];
+  const lineMatch = output.match(/on line (\d+)/i);
+  const messageMatch = output.match(/PHP Parse error:\s*(.+?)(?:\s+in\s+(.+?)\s+on line \d+)?$/im) ?? output.match(/Parse error:\s*(.+?)(?:\s+in\s+(.+?)\s+on line \d+)?$/im);
+  const reported = messageMatch?.[2]?.trim();
+  if (reported && !pathsEqual(path.resolve(cwd, reported), path.resolve(cwd, filePath)))
+    return [];
+  return [
+    {
+      id: `php-lint:${lineMatch?.[1] ?? "1"}`,
+      message: messageMatch?.[1]?.trim() ?? output,
+      filePath,
+      line: lineMatch ? Number.parseInt(lineMatch[1], 10) : 1,
+      column: 1,
+      severity: "error",
+      semantic: "blocking",
+      tool: "php-lint",
+      rule: "syntax",
+      fixable: false
+    }
+  ];
+}
+const phpLintRunner = {
+  id: "php-lint",
+  appliesTo: ["php"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "php-lint");
+    const cmd = ctx.analysisRootMode === "adopted" ? resolveAdoptedRootCommand("php", ctx, cwd) : await php.isAvailableAsync(cwd) ? php.getCommand(cwd) : null;
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const result = await safeSpawnAsync(cmd, ["-l", absPath], {
+      timeout: 15000,
+      cwd
+    });
+    const run = parseToolRun("php-lint", {
+      result,
+      output: `${result.stdout ?? ""}
+${result.stderr ?? ""}`,
+      exitCodes: PHP_LINT_EXIT_CODES
+    }, (output) => parsePhpLintOutput(output, ctx.filePath, cwd));
+    if (run.skipped)
+      return run.skipped;
+    return finishParsedRun({
+      tool: "php-lint",
+      ctx,
+      result,
+      diagnostics: run.diagnostics,
+      classify: () => ({ status: "failed", semantic: "blocking" })
+    });
+  }
+};
+export default phpLintRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/phpstan.js

@@ -0,0 +1,90 @@
+import * as path from "node:path";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { getLinterPolicyForCwd, hasPhpstanConfig } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveVendorToolCommand } from "./utils/runner-helpers.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
+const PHPSTAN_EXIT_CODES = { ran: [1] };
+const phpstan = createAvailabilityChecker("phpstan", ".phar");
+export function parsePhpstanJson(raw, fallbackPath, cwd) {
+  try {
+    const output = JSON.parse(raw);
+    const diagnostics = [];
+    for (const [file, fileErrors] of Object.entries(output.files ?? {})) {
+      const filePath = file && file.trim() ? path.isAbsolute(file) ? file : path.resolve(cwd, file) : fallbackPath;
+      for (const err of fileErrors?.messages ?? []) {
+        diagnostics.push({
+          id: `phpstan:${err.line ?? 1}:${err.message.slice(0, 40)}`,
+          message: err.message,
+          filePath,
+          line: err.line ?? 1,
+          column: 1,
+          severity: "error",
+          semantic: "blocking",
+          tool: "phpstan",
+          rule: err.identifier || "phpstan",
+          fixable: false
+        });
+      }
+    }
+    for (const message of output.errors ?? []) {
+      if (typeof message !== "string" || !message.trim())
+        continue;
+      diagnostics.push({
+        id: `phpstan:global:${message.slice(0, 40)}`,
+        message,
+        filePath: fallbackPath,
+        line: 1,
+        column: 1,
+        severity: "error",
+        semantic: "blocking",
+        tool: "phpstan",
+        rule: "phpstan/analysis",
+        fixable: false
+      });
+    }
+    return diagnostics;
+  } catch {
+    return [];
+  }
+}
+async function resolvePhpstan(cwd) {
+  if (await phpstan.isAvailableAsync(cwd))
+    return phpstan.getCommand(cwd);
+  return resolveVendorToolCommand(cwd, "phpstan", ".bat");
+}
+const phpstanRunner = {
+  id: "phpstan",
+  appliesTo: ["php"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "phpstan");
+    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
+    if (policy && !policy.preferredRunners.includes("phpstan")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    if (!hasPhpstanConfig(cwd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const cmd = await resolvePhpstan(cwd);
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const result = await safeSpawnAsync(cmd, ["analyse", "--error-format=json", "--no-progress", absPath], { timeout: 30000, cwd });
+    const run = parseToolRun("phpstan", { result, exitCodes: PHPSTAN_EXIT_CODES }, (out) => parsePhpstanJson(out, ctx.filePath, cwd), { parseOutput: result.stdout ?? "" });
+    if (run.skipped)
+      return run.skipped;
+    const diagnostics = run.diagnostics;
+    return finishParsedRun({
+      tool: "phpstan",
+      ctx,
+      result,
+      diagnostics,
+      classify: () => ({ status: "failed", semantic: "blocking" })
+    });
+  }
+};
+export default phpstanRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/prisma-validate.js

@@ -0,0 +1,66 @@
+import * as path from "node:path";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { PRIORITY } from "../priorities.js";
+import { resolveLocalFirstAsync } from "./utils/runner-helpers.js";
+import { getIsolatedNpxSpawnOptions } from "../../tool-probe.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
+const PRISMA_VALIDATION_REPORT = /\bValidation Error Count:\s*\d+/;
+function parsePrismaValidateOutput(raw, filePath) {
+  const output = raw.split(`
+`).map((line) => line.trim()).filter(Boolean).filter((line) => !line.startsWith("Environment variables loaded")).filter((line) => !line.startsWith("Prisma schema loaded")).join(" ");
+  if (!output)
+    return [];
+  const message = output.match(/Error:\s*(.+)$/i)?.[1]?.trim() ?? output.match(/Validation Error Count:\s*\d+\s*(.+)$/i)?.[1]?.trim() ?? output;
+  const lineMatch = output.match(/:(\d+)(?::\d+)?\b/);
+  return [
+    {
+      id: `prisma-validate:${lineMatch?.[1] ?? "1"}`,
+      message,
+      filePath,
+      line: lineMatch ? Number.parseInt(lineMatch[1], 10) : 1,
+      column: 1,
+      severity: "error",
+      semantic: "blocking",
+      tool: "prisma-validate",
+      rule: "schema",
+      fixable: false
+    }
+  ];
+}
+const prismaValidateRunner = {
+  id: "prisma-validate",
+  appliesTo: ["prisma"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "prisma-validate");
+    const resolved = await resolveLocalFirstAsync("prisma", cwd);
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const result = await safeSpawnAsync(resolved.cmd, [...resolved.args, "validate", "--schema", absPath], {
+      timeout: 20000,
+      cwd,
+      ...resolved.cmd === "npx" ? getIsolatedNpxSpawnOptions() : {}
+    });
+    if (result.error && !result.stdout && !result.stderr) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    if (result.status === 0) {
+      return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    const output = `${result.stdout ?? ""}
+${result.stderr ?? ""}`;
+    const diagnostics = parsePrismaValidateOutput(output, ctx.filePath);
+    if (diagnostics.length === 0) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    return finishParsedRun({
+      tool: "prisma-validate",
+      ctx,
+      result,
+      diagnostics: PRISMA_VALIDATION_REPORT.test(output) ? diagnostics : [],
+      classify: () => ({ status: "failed", semantic: "blocking" })
+    });
+  }
+};
+export default prismaValidateRunner;