@duckmind/dm-linux-x64 0.65.8 → 0.66.2

package/extensions/dm-lens/dist/clients/dispatch/runners/utils/spawn-outcome.js

@@ -1,40 +0,0 @@
-import { LEDGER_FIELD_MAX } from "../../../ledger-bounds.js";
-import { truncatedByOutputCap } from "../../../spawn-output-cap.js";
-export function firstOutputLine(text, max = LEDGER_FIELD_MAX) {
-  for (const line of String(text ?? "").split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed)
-      continue;
-    return trimmed.length > max ? `${trimmed.slice(0, max)}…` : trimmed;
-  }
-  return "";
-}
-export function classifyRunOutcome(input) {
-  const { result, exitCodes, reportMissing } = input;
-  const status = result.status ?? null;
-  const signal = result.signal ?? null;
-  const output = input.output ?? result.stdout;
-  const base = {
-    status,
-    signal,
-    firstOutputLine: firstOutputLine(result.stderr) || firstOutputLine(result.stdout) || firstOutputLine(result.error?.message),
-    outputCapped: truncatedByOutputCap(result)
-  };
-  if (result.error || signal)
-    return { kind: "did-not-run", ...base };
-  if (status === null)
-    return { kind: "did-not-run", ...base };
-  if (reportMissing) {
-    return status === 0 ? { kind: "ran", ...base } : { kind: "report-missing", ...base };
-  }
-  if (status !== 0 && exitCodes && !exitCodes.ran.includes(status)) {
-    return { kind: "rejected-invocation", ...base };
-  }
-  if (status !== 0 && !output?.trim()) {
-    return { kind: "did-not-run", ...base };
-  }
-  return { kind: "ran", ...base };
-}
-export function spawnFailedWithNoOutput(result, output = result.stdout) {
-  return classifyRunOutcome({ result, output }).kind !== "ran" && !output?.trim();
-}

package/extensions/dm-lens/dist/clients/dispatch/runners/utils/tool-failure.js

@@ -1,117 +0,0 @@
-import { incrementDegradationCount } from "../../../degradation-ledger.js";
-import { truncateForLedger } from "../../../ledger-bounds.js";
-import { classifyRunOutcome, firstOutputLine } from "./spawn-outcome.js";
-function describeEnding(input) {
-  if (input.outputCapped)
-    return "was stopped at its output cap";
-  if (input.signal)
-    return `was killed by ${input.signal}`;
-  if (input.status === null)
-    return "did not run (spawn failure)";
-  return `exited ${input.status}`;
-}
-export function formatToolFailure(input) {
-  const entries = Object.entries(input.fields ?? {}).filter(([, value]) => value !== undefined && value !== "");
-  const identity = entries.length ? `${input.tool} (${entries.map(([key, value]) => `${key}=${value}`).join(", ")})` : input.tool;
-  const what = describeEnding(input);
-  const missing = input.reportMissing ? "no report file" : "no output";
-  const detail = firstOutputLine(input.stderr) || firstOutputLine(input.stdout) || "no stderr";
-  return truncateForLedger(`${identity} ${what} with ${missing}: ${detail}`);
-}
-export function formatRunOutcomeFailure(tool, outcome, fields) {
-  return formatToolFailure({
-    tool,
-    status: outcome.status,
-    signal: outcome.signal,
-    outputCapped: outcome.outputCapped,
-    stderr: outcome.firstOutputLine,
-    reportMissing: outcome.kind === "report-missing",
-    fields: { outcome: outcome.kind, ...fields }
-  });
-}
-export function skipUnlessToolRan(tool, input, fields) {
-  const outcome = classifyRunOutcome(input);
-  if (outcome.kind === "ran")
-    return null;
-  incrementDegradationCount({
-    kind: "runner-empty-result",
-    subject: tool,
-    reason: formatRunOutcomeFailure(tool, outcome, fields)
-  });
-  return { status: "skipped", diagnostics: [], semantic: "none" };
-}
-export function recordParsedNothing(input) {
-  const { tool, status, output, parsedCount } = input;
-  if (parsedCount > 0)
-    return false;
-  if (!status)
-    return false;
-  const text = output ?? "";
-  if (!text.trim())
-    return false;
-  const entries = Object.entries(input.fields ?? {}).filter(([, value]) => value !== undefined && value !== "");
-  const identity = entries.length ? `${tool} (${entries.map(([key, value]) => `${key}=${value}`).join(", ")})` : tool;
-  incrementDegradationCount({
-    kind: "runner-parsed-nothing",
-    subject: tool,
-    reason: truncateForLedger(`${identity} exited ${status} with ${text.length} chars of output but the parser read 0 diagnostics: ${firstOutputLine(text) || "no first line"}`)
-  });
-  return true;
-}
-export function parseToolRun(tool, input, parse, options = {}) {
-  const skipped = skipUnlessToolRan(tool, input, options.fields);
-  if (skipped)
-    return { skipped, diagnostics: [], parsedNothing: false };
-  const output = options.parseOutput ?? input.output ?? input.result.stdout ?? "";
-  const diagnostics = [...parse(output)];
-  const parsedNothing = recordParsedNothing({
-    tool,
-    status: input.result.status ?? null,
-    output,
-    parsedCount: diagnostics.length,
-    fields: options.fields
-  });
-  if (parsedNothing && options.skipWhenParsedNothing) {
-    return {
-      skipped: { status: "skipped", diagnostics: [], semantic: "none" },
-      diagnostics: [],
-      parsedNothing
-    };
-  }
-  return { skipped: null, diagnostics, parsedNothing };
-}
-export function finishParsedRun(input) {
-  const raw = `${input.result.stdout ?? ""}${input.result.stderr ?? ""}`;
-  const status = input.result.status ?? null;
-  if (input.diagnostics.length === 0) {
-    if (status !== 0 && raw.trim().length > 0) {
-      return {
-        status: "failed",
-        diagnostics: [
-          {
-            id: `${input.tool}:parse-error:1`,
-            message: `${input.tool} exited ${status} but its output could not be parsed`,
-            filePath: input.ctx.filePath,
-            line: 1,
-            column: 1,
-            severity: "warning",
-            semantic: "warning",
-            tool: input.tool
-          }
-        ],
-        semantic: "warning"
-      };
-    }
-    return { status: "succeeded", diagnostics: [], semantic: "none" };
-  }
-  const mapped = input.classify?.(input.diagnostics);
-  if (mapped) {
-    return { ...mapped, diagnostics: input.diagnostics };
-  }
-  const hasBlocking = input.diagnostics.some((d) => d.semantic === "blocking");
-  return {
-    status: hasBlocking ? "failed" : "succeeded",
-    diagnostics: input.diagnostics,
-    semantic: hasBlocking ? "blocking" : "warning"
-  };
-}

package/extensions/dm-lens/dist/clients/dispatch/runners/utils/toolchain-availability.js

@@ -1,88 +0,0 @@
-import { createAvailabilityLatch, logAvailabilityDecision } from "./availability-policy.js";
-import { probeAvailabilityCandidates } from "./candidate-probe.js";
-import { createAvailabilityProbeFlight } from "../../../availability-probe-flight.js";
-import { createGenerationSource } from "../../../generation-guard.js";
-import { createSingleFlight } from "../../../single-flight.js";
-const toolchainGenerations = createGenerationSource("toolchain-availability");
-const toolchainProbeFlights = createAvailabilityProbeFlight({ generation: toolchainGenerations.current });
-export function createToolchainAvailability(config) {
-  const availabilityLatch = createAvailabilityLatch();
-  let toolPath = null;
-  let sweepSawTransient = false;
-  let sweepTransientCause = "probe-timeout";
-  let sweepHostStallMs = 0;
-  let sweepEvidence;
-  const ensureFlight = createSingleFlight({
-    generation: toolchainGenerations.current
-  });
-  async function findPath() {
-    if (toolPath)
-      return toolPath;
-    const paths = process.platform === "win32" ? config.windowsPaths : config.unixPaths;
-    const handle = toolchainGenerations.capture();
-    const shared = toolchainProbeFlights.run(`toolchain:${config.tool}|${config.probeArgs.join("|")}|${config.windowsPaths.join("|")}|${config.unixPaths.join("|")}`, () => probeAvailabilityCandidates(paths, config.probeArgs, config.budgetMs));
-    const sweep = await shared.promise;
-    handle.guardedWrite(`findPath:${config.tool}`, () => {
-      sweepSawTransient = sweep.sawTransient;
-      sweepTransientCause = sweep.transientCause;
-      sweepHostStallMs = sweep.hostStallMs;
-      sweepEvidence = sweep.evidence;
-      if (sweep.foundPath)
-        toolPath = sweep.foundPath;
-    });
-    return sweep.foundPath;
-  }
-  async function resolveAvailability() {
-    const startedAt = Date.now();
-    const handle = toolchainGenerations.capture();
-    const resolvedPath = await findPath();
-    const found = resolvedPath !== null;
-    const superseded = !handle.isCurrent();
-    if (found) {
-      handle.guardedWrite(`latch:${config.tool}`, () => availabilityLatch.noteAvailable());
-      config.log(`${config.label} found: ${resolvedPath}`);
-      logAvailabilityDecision({
-        tool: config.tool,
-        verdict: "available",
-        outcome: "success",
-        cause: "ok",
-        elapsedMs: Date.now() - startedAt,
-        latched: !superseded,
-        hostStallMs: sweepHostStallMs,
-        budgetMs: config.budgetMs,
-        classifiedBy: "probe",
-        ...sweepEvidence !== undefined && { evidence: sweepEvidence }
-      });
-      return true;
-    }
-    const outcome = sweepSawTransient ? "transient" : "missing";
-    const cause = sweepSawTransient ? sweepTransientCause : "not-found";
-    const retryAfterMs = handle.guardedWrite(`latch:${config.tool}`, () => availabilityLatch.noteUnavailable(outcome, cause)) ?? 0;
-    logAvailabilityDecision({
-      tool: config.tool,
-      verdict: "unavailable",
-      outcome,
-      cause,
-      elapsedMs: Date.now() - startedAt,
-      latched: !superseded && outcome !== "transient",
-      hostStallMs: sweepHostStallMs,
-      ...retryAfterMs > 0 && { retryAfterMs },
-      budgetMs: config.budgetMs,
-      classifiedBy: "probe",
-      ...sweepEvidence !== undefined && { evidence: sweepEvidence }
-    });
-    return false;
-  }
-  async function isAvailable() {
-    const memo = availabilityLatch.read();
-    if (memo !== null)
-      return memo;
-    return ensureFlight.run("availability", resolveAvailability);
-  }
-  function reset() {
-    toolPath = null;
-    availabilityLatch.reset();
-    toolchainGenerations.bump();
-  }
-  return { findPath, isAvailable, reset };
-}

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

@@ -1,8 +0,0 @@
-import * as fs from "node:fs";
-export function readFileContent(filePath) {
-  try {
-    return fs.readFileSync(filePath, "utf-8");
-  } catch {
-    return;
-  }
-}

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

@@ -1,106 +0,0 @@
-import * as fs from "node:fs";
-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, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-const vale = createAvailabilityChecker("vale", ".exe");
-function findValeConfig(cwd) {
-  const local = path.join(cwd, ".vale.ini");
-  if (fs.existsSync(local))
-    return local;
-  let current = path.resolve(cwd);
-  while (true) {
-    const candidate = path.join(current, ".vale.ini");
-    if (fs.existsSync(candidate))
-      return candidate;
-    const parent = path.dirname(current);
-    if (parent === current)
-      break;
-    current = parent;
-  }
-  return;
-}
-export function parseValeOutput(raw, filePath, cwd) {
-  const diagnostics = [];
-  if (!raw.trim())
-    return diagnostics;
-  const absTarget = path.resolve(cwd, filePath);
-  try {
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object")
-      return diagnostics;
-    for (const [reported, alerts] of Object.entries(parsed)) {
-      if (!Array.isArray(alerts))
-        continue;
-      if (reported && !pathsEqual(path.resolve(cwd, reported), absTarget))
-        continue;
-      for (const alert of alerts) {
-        if (!alert.Message)
-          continue;
-        const severityMap = {
-          error: "error",
-          warning: "warning",
-          info: "info",
-          suggestion: "info"
-        };
-        const severity = severityMap[alert.Severity?.toLowerCase() ?? ""] ?? "warning";
-        diagnostics.push({
-          id: `vale-${alert.Line}-${alert.Check ?? "unknown"}`,
-          message: `[${alert.Check ?? "vale"}] ${alert.Message}`,
-          filePath,
-          line: alert.Line ?? 1,
-          column: alert.Span?.[0] ?? 1,
-          severity,
-          semantic: severity === "error" ? "blocking" : "warning",
-          tool: "vale",
-          rule: alert.Check ?? "vale",
-          fixable: false
-        });
-      }
-    }
-  } catch {
-    return diagnostics;
-  }
-  return diagnostics;
-}
-const valeRunner = {
-  id: "vale",
-  appliesTo: ["markdown"],
-  priority: PRIORITY.DOC_QUALITY,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "vale");
-    if (!findValeConfig(cwd)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    let cmd = null;
-    if (await vale.isAvailableAsync(cwd)) {
-      cmd = vale.getCommand(cwd);
-    } else {
-      cmd = await resolveToolCommandWithInstallFallback(cwd, "vale");
-    }
-    if (!cmd)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    const result = await safeSpawnAsync(cmd, ["--output", "JSON", ctx.filePath], { cwd, timeout: 15000 });
-    const run = parseToolRun("vale", {
-      result,
-      exitCodes: { ran: [1, 2] }
-    }, (raw) => parseValeOutput(raw, ctx.filePath, cwd));
-    if (run.skipped)
-      return run.skipped;
-    const diagnostics = run.diagnostics;
-    if (diagnostics.length === 0) {
-      return { status: "succeeded", diagnostics: [], semantic: "none" };
-    }
-    const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-    return {
-      status: hasBlocking ? "failed" : "succeeded",
-      diagnostics,
-      semantic: hasBlocking ? "blocking" : "warning"
-    };
-  }
-};
-export default valeRunner;

package/extensions/dm-lens/dist/clients/dispatch/runners/yaml-rule-parser.js

@@ -1,163 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import yaml from "../../deps/js-yaml.js";
-import { BoundedLruCache } from "../../bounded-cache.js";
-import { compareOrdinal } from "../../string-utils.js";
-const OVERLY_BROAD_PATTERNS = ["$NAME", "$FIELD", "$_", "$X", "$VAR", "$EXPR"];
-export const MAX_BLOCKING_RULE_COMPLEXITY = 8;
-export const RULES_CACHE_FRESHNESS_CADENCE_MS = 2000;
-const rulesCache = new BoundedLruCache(64);
-const blockingRulesCache = new BoundedLruCache(64);
-const contentRulesCache = new BoundedLruCache(64);
-const contentBlockingRulesCache = new BoundedLruCache(64);
-export function loadYamlRules(ruleDir, severityFilter) {
-  return getCachedRules(ruleDir, severityFilter);
-}
-function findYamlRuleFiles(ruleDir) {
-  let entries;
-  try {
-    entries = fs.readdirSync(ruleDir, { withFileTypes: true }).sort((a, b) => compareOrdinal(a.name, b.name));
-  } catch {
-    return [];
-  }
-  const files = [];
-  for (const entry of entries) {
-    const full = path.join(ruleDir, entry.name);
-    if (entry.isDirectory()) {
-      files.push(...findYamlRuleFiles(full));
-    } else if (entry.isFile() && /\.ya?ml$/i.test(entry.name)) {
-      files.push(full);
-    }
-  }
-  return files;
-}
-function loadYamlRuleFiles(files, severityFilter) {
-  const rules = [];
-  for (const file of files) {
-    let content;
-    try {
-      content = fs.readFileSync(file, "utf-8");
-    } catch {
-      continue;
-    }
-    const documents = content.split(/^---\s*$/m).filter((doc) => doc.trim());
-    for (const document of documents) {
-      const rule = parseSimpleYaml(document.trim());
-      if (!rule?.id)
-        continue;
-      if (severityFilter && rule.severity !== severityFilter)
-        continue;
-      rules.push(rule);
-    }
-  }
-  return rules;
-}
-export function loadYamlRulesUncached(ruleDir, severityFilter) {
-  return loadYamlRuleFiles(findYamlRuleFiles(ruleDir), severityFilter);
-}
-export function loadYamlRulesFresh(ruleDir, severityFilter) {
-  const files = findYamlRuleFiles(ruleDir);
-  const hash = createHash("sha256");
-  for (const file of files) {
-    hash.update(path.relative(ruleDir, file));
-    hash.update("\x00");
-    try {
-      hash.update(fs.readFileSync(file));
-    } catch {
-      hash.update("missing");
-    }
-    hash.update("\x00");
-  }
-  const signature = hash.digest("hex");
-  const cache = severityFilter === "error" ? contentBlockingRulesCache : contentRulesCache;
-  const cached = cache.get(ruleDir);
-  if (cached?.signature === signature)
-    return cached.rules;
-  const rules = loadYamlRuleFiles(files, severityFilter);
-  cache.set(ruleDir, { rules, signature });
-  return rules;
-}
-function getCachedRules(ruleDir, severityFilter) {
-  if (!fs.existsSync(ruleDir)) {
-    return [];
-  }
-  const cache = severityFilter === "error" ? blockingRulesCache : rulesCache;
-  const cached = cache.get(ruleDir);
-  const now = Date.now();
-  if (cached && now - cached.checkedAtMs < RULES_CACHE_FRESHNESS_CADENCE_MS) {
-    return cached.rules;
-  }
-  const files = findYamlRuleFiles(ruleDir);
-  const fileStamps = files.flatMap((file) => {
-    try {
-      const stat = fs.statSync(file);
-      return [{ path: file, mtimeMs: stat.mtimeMs, size: stat.size }];
-    } catch {
-      return [];
-    }
-  });
-  const metadataMatches = cached?.files.length === fileStamps.length && cached.files.every((file, index) => file.path === fileStamps[index].path && file.mtimeMs === fileStamps[index].mtimeMs && file.size === fileStamps[index].size);
-  if (cached && metadataMatches) {
-    cached.checkedAtMs = now;
-    return cached.rules;
-  }
-  const rules = loadYamlRuleFiles(files, severityFilter);
-  cache.set(ruleDir, { rules, files: fileStamps, checkedAtMs: now });
-  return rules;
-}
-export function isOverlyBroadPattern(pattern) {
-  if (!pattern)
-    return false;
-  if (typeof pattern !== "string")
-    return false;
-  if (OVERLY_BROAD_PATTERNS.includes(pattern.trim()))
-    return true;
-  return /^\$[A-Z_]+$/i.test(pattern.trim());
-}
-export function isStructuredRule(rule) {
-  if (!rule.rule)
-    return false;
-  const hasRichPattern = typeof rule.rule.pattern === "object" && rule.rule.pattern !== null;
-  return !!(hasRichPattern || rule.rule.has || rule.rule.any || rule.rule.all || rule.rule.not || rule.rule.regex);
-}
-export function calculateRuleComplexity(condition) {
-  if (!condition)
-    return 0;
-  let score = 0;
-  if (condition.has)
-    score += 3;
-  if (condition.not)
-    score += 2;
-  if (condition.regex)
-    score += 2;
-  if (condition.any)
-    score += condition.any.length * 2;
-  if (condition.all)
-    score += condition.all.length * 3;
-  if (condition.has)
-    score += calculateRuleComplexity(condition.has);
-  if (condition.not)
-    score += calculateRuleComplexity(condition.not);
-  if (condition.any) {
-    for (const sub of condition.any)
-      score += calculateRuleComplexity(sub);
-  }
-  if (condition.all) {
-    for (const sub of condition.all)
-      score += calculateRuleComplexity(sub);
-  }
-  return score;
-}
-export function parseSimpleYaml(content) {
-  let parsed;
-  try {
-    parsed = yaml.load(content);
-  } catch {
-    return null;
-  }
-  if (!parsed || typeof parsed !== "object")
-    return null;
-  const rule = parsed;
-  return rule.id ? rule : null;
-}

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

@@ -1,83 +0,0 @@
-import * as path from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { logRunnerAdvisoryOnce } from "../../tool-cwd.js";
-import { getLinterPolicyForCwd, hasYamllintConfig } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveRunnerCwd, resolveToolCommandWithInstallFallback } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-const yamllint = createAvailabilityChecker("yamllint", ".exe");
-
-export { hasYamllintConfig };
-function parseYamllintParsable(raw, filePath, cwd) {
-  const diagnostics = [];
-  const absTarget = path.resolve(cwd, filePath);
-  for (const line of raw.split(/\r?\n/)) {
-    if (!line.trim())
-      continue;
-    const match = line.match(/^(.*?):(\d+):(\d+):\s*\[(error|warning)\]\s*(.*?)\s*\(([^)]+)\)\s*$/i);
-    if (!match)
-      continue;
-    if (!pathsEqual(path.resolve(cwd, match[1]), absTarget))
-      continue;
-    const severity = match[4].toLowerCase() === "error" ? "error" : "warning";
-    diagnostics.push({
-      id: `yamllint-${match[2]}-${match[3]}-${match[6]}`,
-      message: `[${match[6]}] ${match[5]}`,
-      filePath,
-      line: Number(match[2]),
-      column: Number(match[3]),
-      severity,
-      semantic: severity === "error" ? "blocking" : "warning",
-      tool: "yamllint",
-      rule: match[6]
-    });
-  }
-  return diagnostics;
-}
-const yamllintRunner = {
-  id: "yamllint",
-  appliesTo: ["yaml"],
-  priority: PRIORITY.YAML_LINT,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "yamllint");
-    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-    if (policy && !policy.preferredRunners.includes("yamllint")) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const hasConfig = hasYamllintConfig(cwd);
-    if (!hasConfig) {
-      logRunnerAdvisoryOnce(ctx, "yamllint", cwd, "yamllint: no config detected, running with default rules");
-    }
-    let cmd = null;
-    if (await yamllint.isAvailableAsync(cwd)) {
-      cmd = yamllint.getCommand(cwd);
-    } else {
-      cmd = await resolveToolCommandWithInstallFallback(cwd, "yamllint");
-    }
-    if (!cmd)
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    const result = await safeSpawnAsync(cmd, ["-f", "parsable", ctx.filePath], {
-      cwd,
-      timeout: 15000
-    });
-    const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-    const run = parseToolRun("yamllint", {
-      result,
-      output: result.stdout,
-      exitCodes: { ran: [1, 2] }
-    }, (out) => parseYamllintParsable(out, ctx.filePath, cwd), { parseOutput: raw });
-    if (run.skipped)
-      return run.skipped;
-    const diagnostics = run.diagnostics;
-    return finishParsedRun({
-      tool: "yamllint",
-      ctx,
-      result,
-      diagnostics
-    });
-  }
-};
-export default yamllintRunner;

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

@@ -1,72 +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 { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { PRIORITY } from "../priorities.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const zig = createAvailabilityChecker("zig", ".exe", ["version"]);
-function parseZigOutput(raw, filePath, cwd) {
-  const diagnostics = [];
-  const absTarget = path.resolve(cwd, filePath);
-  for (const line of raw.split(/\r?\n/)) {
-    const match = line.match(/^(.*?):(\d+):(\d+):\s*(error|warning|note):\s*(.+)$/);
-    if (!match)
-      continue;
-    const [, rawFile, lineStr, colStr, level, message] = match;
-    if (!pathsEqual(path.resolve(cwd, rawFile.trim()), absTarget))
-      continue;
-    const severity = level === "error" ? "error" : "warning";
-    diagnostics.push({
-      id: `zig-${level}-${lineStr}-${colStr}`,
-      message,
-      filePath,
-      line: Number.parseInt(lineStr, 10) || 1,
-      column: Number.parseInt(colStr, 10) || 1,
-      severity,
-      semantic: "warning",
-      tool: "zig",
-      rule: `zig-${level}`,
-      fixable: false
-    });
-  }
-  return diagnostics;
-}
-const zigCheckRunner = {
-  id: "zig-check",
-  appliesTo: ["zig"],
-  priority: PRIORITY.GENERAL_ANALYSIS,
-  skipTestFiles: false,
-  async run(ctx) {
-    const cwd = resolveRunnerCwd(ctx, "zig-check");
-    if (!await zig.isAvailableAsync(cwd)) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const cmd = zig.getCommand(cwd);
-    const absPath = path.resolve(cwd, ctx.filePath);
-    const result = await safeSpawnAsync(cmd, ["build-exe", absPath, "-fno-emit-bin"], { cwd, timeout: 30000 });
-    if (result.error && !result.stdout && !result.stderr) {
-      return { status: "skipped", diagnostics: [], semantic: "none" };
-    }
-    const raw = `${result.stdout || ""}
-${result.stderr || ""}`;
-    const parsed = parseToolRun("zig-check", {
-      result,
-      output: raw,
-      exitCodes: { ran: [1, 2] }
-    }, (output) => parseZigOutput(output, ctx.filePath, cwd));
-    if (parsed.skipped)
-      return parsed.skipped;
-    return finishParsedRun({
-      tool: "zig-check",
-      ctx,
-      result,
-      diagnostics: parsed.diagnostics,
-      classify: (diagnostics) => ({
-        status: diagnostics.some((d) => d.severity === "error") ? "failed" : "succeeded",
-        semantic: "warning"
-      })
-    });
-  }
-};
-export default zigCheckRunner;