@duckmind/dm-linux-x64 0.66.0 → 0.66.2

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

@@ -1,305 +0,0 @@
-import * as path from "node:path";
-import { findLocalBinUpwards } 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 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

@@ -1,70 +0,0 @@
-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 } 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");
-    if (!await php.isAvailableAsync(cwd)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const cmd = php.getCommand(cwd);
-    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

@@ -1,90 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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";
-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 });
-    if (result.error && !result.stdout && !result.stderr) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    if (result.status === 0) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    const diagnostics = parsePrismaValidateOutput(`${result.stdout ?? ""}
-${result.stderr ?? ""}`, ctx.filePath);
-    if (diagnostics.length === 0) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    return {
-      status: "failed",
-      diagnostics,
-      semantic: "blocking"
-    };
-  }
-};
-export default prismaValidateRunner;