@duckmind/dm-linux-x64 0.65.4 → 0.65.6

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

@@ -0,0 +1,307 @@
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import { incrementDegradationCount } from "../../degradation-ledger.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { probeToolAsync } from "../../tool-probe.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { PRIORITY } from "../priorities.js";
+import { classifyProbeFailure, createAvailabilityLatch, isLatchingOutcome, logAvailabilityDecision, startHostStallSampler } from "./utils/availability-policy.js";
+const PS_SCRIPT = `
+param([string]$FilePath)
+Import-Module PSScriptAnalyzer -ErrorAction Stop
+$results = @(Invoke-ScriptAnalyzer -Path $FilePath | Select-Object RuleName,@{N='Severity';E={$_.Severity.ToString()}},Line,Column,Message)
+if ($results.Count -eq 0) { Write-Output '[]'; exit 0 }
+$results | ConvertTo-Json -Depth 3 -Compress
+`.trim();
+const PS_TIMEOUT_MS = 30000;
+function spawnPs(cmd, args, options) {
+  const { timeoutMs = PS_TIMEOUT_MS, cwd } = options;
+  return safeSpawnAsync(cmd, args, {
+    cwd,
+    timeout: timeoutMs,
+    resourceLabel: "psscriptanalyzer"
+  });
+}
+const psCmdLatch = createAvailabilityLatch();
+const psAnalyzerLatchByCmd = new Map;
+const psExecLatchByCmd = new Map;
+let psCmd = null;
+function notePsDecision(latch, tool, verdict) {
+  let retryAfterMs;
+  if (verdict.available) {
+    latch.noteAvailable();
+  } else {
+    const delay = latch.noteUnavailable(verdict.outcome, verdict.cause);
+    if (delay > 0)
+      retryAfterMs = delay;
+  }
+  logAvailabilityDecision({
+    tool,
+    verdict: verdict.available ? "available" : "unavailable",
+    outcome: verdict.available ? "success" : verdict.outcome,
+    cause: verdict.available ? "ok" : verdict.cause,
+    elapsedMs: verdict.elapsedMs,
+    latched: verdict.available || isLatchingOutcome(verdict.outcome),
+    classifiedBy: "probe",
+    hostStallMs: verdict.hostStallMs,
+    ...retryAfterMs !== undefined && { retryAfterMs },
+    budgetMs: PS_TIMEOUT_MS
+  });
+}
+export function resetPsScriptAnalyzerAvailability() {
+  psCmdLatch.reset();
+  psAnalyzerLatchByCmd.clear();
+  psExecLatchByCmd.clear();
+  psCmd = null;
+}
+async function resolvePowerShellCmd() {
+  const memo = psCmdLatch.read();
+  if (memo !== null)
+    return memo ? psCmd : null;
+  let transient = null;
+  let rejected = null;
+  let elapsedTotalMs = 0;
+  let stallTotalMs = 0;
+  for (const candidate of ["pwsh", "powershell"]) {
+    const sampler = startHostStallSampler();
+    const startedAt = Date.now();
+    const result = await probeToolAsync(candidate, ["-NoProfile", "-NonInteractive", "-Command", "exit 0"], { timeout: PS_TIMEOUT_MS, resourceLabel: "psscriptanalyzer" });
+    const hostStallMs = sampler.stop();
+    const elapsedMs = Date.now() - startedAt;
+    elapsedTotalMs += elapsedMs;
+    stallTotalMs += hostStallMs;
+    if (!result.error && result.status === 0) {
+      psCmd = candidate;
+      notePsDecision(psCmdLatch, "powershell", {
+        available: true,
+        elapsedMs,
+        hostStallMs
+      });
+      return candidate;
+    }
+    const classified = classifyProbeFailure(result, { hostStallMs });
+    if (classified.outcome === "transient")
+      transient ??= classified;
+    else if (classified.outcome !== "missing")
+      rejected ??= classified;
+  }
+  psCmd = null;
+  const verdict = transient ?? rejected ?? {
+    outcome: "missing",
+    cause: "not-found"
+  };
+  notePsDecision(psCmdLatch, "powershell", {
+    available: false,
+    outcome: verdict.outcome,
+    cause: verdict.cause,
+    elapsedMs: elapsedTotalMs,
+    hostStallMs: stallTotalMs
+  });
+  return null;
+}
+async function checkModuleAvailable(cmd) {
+  let latch = psAnalyzerLatchByCmd.get(cmd);
+  if (!latch) {
+    latch = createAvailabilityLatch();
+    psAnalyzerLatchByCmd.set(cmd, latch);
+  }
+  const memo = latch.read();
+  if (memo !== null)
+    return memo;
+  const sampler = startHostStallSampler();
+  const startedAt = Date.now();
+  const result = await probeToolAsync(cmd, [
+    "-NoProfile",
+    "-NonInteractive",
+    "-Command",
+    "if (Get-Module -ListAvailable PSScriptAnalyzer) { exit 0 } else { exit 1 }"
+  ], { timeout: PS_TIMEOUT_MS, resourceLabel: "psscriptanalyzer" });
+  const hostStallMs = sampler.stop();
+  const elapsedMs = Date.now() - startedAt;
+  if (!result.error && result.status === 0) {
+    notePsDecision(latch, "psscriptanalyzer", {
+      available: true,
+      elapsedMs,
+      hostStallMs
+    });
+    return true;
+  }
+  const moduleAbsent = result.status === 1 && !result.failure && !result.error;
+  const classified = classifyProbeFailure(result, {
+    hostStallMs,
+    ...moduleAbsent && { unclassifiedFailureOutcome: "missing" }
+  });
+  let { outcome, cause } = classified;
+  if (!moduleAbsent && outcome !== "transient") {
+    outcome = "transient";
+    cause = "probe-rejected";
+  }
+  notePsDecision(latch, "psscriptanalyzer", {
+    available: false,
+    outcome,
+    cause,
+    elapsedMs,
+    hostStallMs
+  });
+  return false;
+}
+function parsePSAnalyzerOutput(raw, filePath) {
+  const trimmed = raw.trim();
+  if (!trimmed)
+    return null;
+  if (trimmed === "[]")
+    return [];
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch {
+    return null;
+  }
+  const items = Array.isArray(parsed) ? parsed : [parsed];
+  return items.filter((item) => item.Message && item.Line).map((item) => {
+    const sev = (item.Severity ?? "Warning").toLowerCase();
+    const severity = sev === "error" || sev === "parseerror" ? "error" : sev === "information" ? "info" : "warning";
+    const rule = item.RuleName ?? "PSScriptAnalyzer";
+    return {
+      id: `psscriptanalyzer-${rule}-${item.Line}`,
+      message: `[${rule}] ${item.Message}`,
+      filePath,
+      line: item.Line,
+      column: item.Column ?? 1,
+      severity,
+      semantic: severity === "error" ? "blocking" : "warning",
+      tool: "psscriptanalyzer",
+      rule,
+      fixable: false
+    };
+  });
+}
+const psScriptAnalyzerRunner = {
+  id: "psscriptanalyzer",
+  appliesTo: ["powershell"],
+  priority: PRIORITY.GENERAL_ANALYSIS,
+  skipTestFiles: false,
+  async run(ctx) {
+    const cmd = await resolvePowerShellCmd();
+    if (!cmd)
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    if (!await checkModuleAvailable(cmd)) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    let execLatch = psExecLatchByCmd.get(cmd);
+    if (!execLatch) {
+      execLatch = createAvailabilityLatch();
+      psExecLatchByCmd.set(cmd, execLatch);
+    }
+    if (execLatch.read() === false) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const cwd = resolveRunnerCwd(ctx, "psscriptanalyzer");
+    const absPath = path.resolve(cwd, ctx.filePath);
+    const tmpScript = path.join(os.tmpdir(), `dm-lens-psa-${process.pid}.ps1`);
+    await fs.writeFile(tmpScript, PS_SCRIPT, "utf-8");
+    try {
+      const sampler = startHostStallSampler();
+      const startedAt = Date.now();
+      const result = await spawnPs(cmd, [
+        "-NoProfile",
+        "-NonInteractive",
+        "-File",
+        tmpScript,
+        "-FilePath",
+        absPath
+      ], { timeoutMs: PS_TIMEOUT_MS, cwd });
+      const hostStallMs = sampler.stop();
+      const elapsedMs = Date.now() - startedAt;
+      if (result.status === null) {
+        const classified = classifyProbeFailure(result, { hostStallMs });
+        let { outcome, cause } = classified;
+        if (outcome !== "transient") {
+          outcome = "transient";
+          cause = "probe-rejected";
+        }
+        notePsDecision(execLatch, "psscriptanalyzer-exec", {
+          available: false,
+          outcome,
+          cause,
+          elapsedMs,
+          hostStallMs
+        });
+        incrementDegradationCount({
+          kind: "grammar-blocked",
+          subject: "psscriptanalyzer",
+          reason: `PowerShell (${cmd}) -File analysis exited with no status -- crash or signal-killed process`
+        });
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+      }
+      if (result.status !== 0) {
+        const stderrText = result.stderr ?? "";
+        const policyDenied = /securityerror/i.test(stderrText) && (/execution polic(y|ies)/i.test(stderrText) || /running scripts is disabled/i.test(stderrText) || /unauthorizedaccess/i.test(stderrText));
+        const classified = classifyProbeFailure(result, { hostStallMs });
+        let { outcome, cause } = classified;
+        if (policyDenied) {
+          outcome = "non-installable";
+          cause = "policy-denied";
+        } else if (outcome !== "transient") {
+          outcome = "transient";
+          cause = "probe-rejected";
+        }
+        notePsDecision(execLatch, "psscriptanalyzer-exec", {
+          available: false,
+          outcome,
+          cause,
+          elapsedMs,
+          hostStallMs
+        });
+        incrementDegradationCount({
+          kind: "grammar-blocked",
+          subject: "psscriptanalyzer",
+          reason: policyDenied ? `PowerShell execution policy blocked -File analysis for ${cmd}: ${stderrText.trim().split(`
+`)[0] || "SecurityError"}` : `PowerShell -File analysis for ${cmd} exited ${result.status}: ${stderrText.trim().slice(0, 200) || "no stderr"}`
+        });
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+      }
+      if (execLatch.read() === null) {
+        notePsDecision(execLatch, "psscriptanalyzer-exec", {
+          available: true,
+          elapsedMs,
+          hostStallMs
+        });
+      }
+      const diagnostics = parsePSAnalyzerOutput(result.stdout, ctx.filePath);
+      if (diagnostics === null) {
+        const unreadableReason = result.stdout.trim() ? "unparseable" : "empty";
+        logAvailabilityDecision({
+          tool: "psscriptanalyzer-stdout",
+          verdict: "unavailable",
+          outcome: "transient",
+          cause: "empty-result",
+          elapsedMs,
+          latched: false,
+          hostStallMs,
+          budgetMs: PS_TIMEOUT_MS,
+          classifiedBy: "caller"
+        });
+        incrementDegradationCount({
+          kind: "grammar-blocked",
+          subject: "psscriptanalyzer",
+          reason: `PowerShell -File analysis for ${cmd} exited 0 but stdout was ${unreadableReason}`
+        });
+        return { status: "skipped", diagnostics: [], semantic: "none" };
+      }
+      if (diagnostics.length === 0) {
+        return { status: "succeeded", diagnostics: [], semantic: "none" };
+      }
+      const hasErrors = diagnostics.some((d) => d.severity === "error");
+      return {
+        status: hasErrors ? "failed" : "succeeded",
+        diagnostics,
+        semantic: hasErrors ? "blocking" : "warning"
+      };
+    } finally {
+      await fs.unlink(tmpScript).catch(() => {});
+    }
+  }
+};
+export default psScriptAnalyzerRunner;

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

@@ -0,0 +1,118 @@
+import { logExtension } from "../../extension-log.js";
+import { getLSPService } from "../../lsp/index.js";
+import { augmentPythonEnvironment, detectPythonEnvironment } from "../../python-environment.js";
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { resolveRunnerCwd } from "../../tool-cwd.js";
+import { PRIORITY } from "../priorities.js";
+import { createAvailabilityChecker, resolveAvailableOrInstall } from "./utils/runner-helpers.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
+const pyright = createAvailabilityChecker("pyright", ".exe");
+const pyrightRunner = {
+  id: "pyright",
+  appliesTo: ["python"],
+  priority: PRIORITY.LSP_FALLBACK,
+  timeoutMs: 75000,
+  async run(ctx) {
+    if (!ctx.pi.getFlag("no-lsp")) {
+      const lspService = getLSPService();
+      await lspService.getClientForFile(ctx.filePath);
+    }
+    const cwd = resolveRunnerCwd(ctx, "pyright");
+    let cmd = null;
+    if (await pyright.isAvailableAsync(cwd)) {
+      cmd = pyright.getCommand(cwd);
+    }
+    if (!cmd) {
+      const installedPath = await resolveAvailableOrInstall(pyright, "pyright", cwd);
+      if (installedPath)
+        cmd = installedPath;
+    }
+    if (!cmd) {
+      const { findCommandAsync } = await import("../../safe-spawn.js");
+      const foundCmd = await findCommandAsync("pyright");
+      if (foundCmd)
+        cmd = foundCmd;
+    }
+    if (!cmd) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const pythonEnvironment = await detectPythonEnvironment(cwd);
+    const env = augmentPythonEnvironment(process.env, pythonEnvironment);
+    const result = await safeSpawnAsync(cmd, ["--outputjson", ctx.filePath], {
+      timeout: 60000,
+      cwd,
+      env
+    });
+    if (result.error) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const output = (result.stdout || "").trim();
+    if (!output) {
+      return finishParsedRun({
+        tool: "pyright",
+        ctx,
+        result,
+        diagnostics: []
+      });
+    }
+    try {
+      const data = JSON.parse(output);
+      const diagnostics = parsePyrightOutput(data, ctx.filePath);
+      return finishParsedRun({
+        tool: "pyright",
+        ctx,
+        result,
+        diagnostics,
+        classify: (diagnostics) => {
+          const hasErrors = diagnostics.some((d) => d.severity === "error");
+          return {
+            status: hasErrors ? "failed" : "succeeded",
+            semantic: hasErrors ? "blocking" : "warning"
+          };
+        }
+      });
+    } catch {
+      logExtension({
+        subsystem: "runner:pyright",
+        message: `JSON parse failed for ${ctx.filePath} — raw output: ${output.slice(0, 200)}`,
+        metadata: { filePath: ctx.filePath }
+      });
+      return {
+        status: "failed",
+        diagnostics: [],
+        semantic: "none",
+        rawOutput: output.slice(0, 500)
+      };
+    }
+  }
+};
+export function normalizePyrightSeverity(raw) {
+  switch (raw) {
+    case "error":
+      return "error";
+    case "information":
+      return "info";
+    default:
+      return "warning";
+  }
+}
+export function parsePyrightOutput(data, _filePath) {
+  const diagnostics = [];
+  const generalDiags = data.generalDiagnostics || [];
+  for (const diag of generalDiags) {
+    const start = diag.range?.start;
+    diagnostics.push({
+      id: `pyright-${diag.rule || start?.line || "unknown"}`,
+      message: diag.message || "Type error",
+      filePath: diag.file || _filePath,
+      line: (start?.line ?? 0) + 1,
+      column: (start?.character ?? 0) + 1,
+      severity: normalizePyrightSeverity(diag.severity),
+      semantic: diag.severity === "error" ? "blocking" : "warning",
+      tool: "pyright",
+      rule: diag.rule
+    });
+  }
+  return diagnostics;
+}
+export default pyrightRunner;

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

@@ -0,0 +1,79 @@
+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 { getAutofixCapability, getLinterPolicyForCwd, getRubocopCommand } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { resolveCommandArgsWithInstallFallback } from "./utils/runner-helpers.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+const SEVERITY_MAP = {
+  fatal: "error",
+  error: "error",
+  warning: "warning",
+  convention: "warning",
+  refactor: "info"
+};
+function parseRubocopJson(raw, filePath, cwd) {
+  try {
+    const output = JSON.parse(raw);
+    const autofix = getAutofixCapability("rubocop");
+    const diagnostics = [];
+    const absTarget = path.resolve(cwd, filePath);
+    for (const file of output.files) {
+      if (file.path && !pathsEqual(path.resolve(cwd, file.path), absTarget))
+        continue;
+      for (const offense of file.offenses) {
+        const severity = SEVERITY_MAP[offense.severity] ?? "warning";
+        diagnostics.push({
+          id: `rubocop:${offense.cop_name}:${offense.location.line}`,
+          message: `${offense.cop_name}: ${offense.message}`,
+          filePath,
+          line: offense.location.line,
+          column: offense.location.column,
+          severity,
+          semantic: severity === "error" ? "blocking" : "warning",
+          tool: "rubocop",
+          rule: offense.cop_name,
+          fixable: offense.correctable,
+          autoFixAvailable: offense.correctable && (autofix?.safePipelineAutofix ?? false),
+          fixKind: offense.correctable && autofix?.fixKind !== "none" ? autofix?.fixKind : undefined
+        });
+      }
+    }
+    return diagnostics;
+  } catch {
+    return [];
+  }
+}
+const rubocopRunner = {
+  id: "rubocop",
+  appliesTo: ["ruby"],
+  priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "rubocop");
+    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
+    if (policy && !policy.preferredRunners.includes("rubocop")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const resolved = await resolveCommandArgsWithInstallFallback(getRubocopCommand(cwd), "rubocop", cwd, ["--version"], 1e4);
+    if (!resolved) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const { cmd, args } = resolved;
+    const result = await safeSpawnAsync(cmd, [...args, "--format", "json", "--no-color", ctx.filePath], { timeout: 30000, cwd });
+    const run = parseToolRun("rubocop", {
+      result,
+      output: `${result.stdout}${result.stderr}`,
+      exitCodes: { ran: [1, 2] }
+    }, (output) => parseRubocopJson(output, ctx.filePath, cwd), { parseOutput: result.stdout });
+    if (run.skipped)
+      return run.skipped;
+    return finishParsedRun({
+      tool: "rubocop",
+      ctx,
+      result,
+      diagnostics: run.diagnostics
+    });
+  }
+};
+export default rubocopRunner;

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

@@ -0,0 +1,69 @@
+import { safeSpawnAsync } from "../../safe-spawn.js";
+import { stripAnsi } from "../../sanitize.js";
+import { getAutofixCapability, getLinterPolicyForCwd, ruffConfigArgs } from "../../tool-policy.js";
+import { PRIORITY } from "../priorities.js";
+import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
+import { parseRuffOutput } from "./utils/diagnostic-parsers.js";
+import { createAvailabilityChecker, resolveAvailableOrInstall, resolveRunnerCwd } from "./utils/runner-helpers.js";
+const ruff = createAvailabilityChecker("ruff", ".exe");
+function parseRuffJson(raw, filePath) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed))
+      return [];
+    const autofix = getAutofixCapability("ruff");
+    return parsed.map((item, index) => {
+      const severity = item.severity === "error" ? "error" : "warning";
+      const code = item.code || "ruff";
+      const toolFixable = Boolean(item.fix);
+      return {
+        id: `ruff-${code}-${item.location?.row ?? index + 1}`,
+        message: item.message || code,
+        filePath: item.filename || filePath,
+        line: item.location?.row ?? 1,
+        column: item.location?.column ?? 1,
+        severity,
+        semantic: severity === "error" ? "blocking" : "warning",
+        tool: "ruff",
+        rule: code,
+        fixable: toolFixable,
+        autoFixAvailable: toolFixable && (autofix?.safePipelineAutofix ?? false),
+        fixKind: toolFixable && autofix?.fixKind !== "none" ? autofix?.fixKind : undefined
+      };
+    });
+  } catch {
+    return [];
+  }
+}
+const ruffRunner = {
+  id: "ruff-lint",
+  appliesTo: ["python"],
+  priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
+  async run(ctx) {
+    const cwd = resolveRunnerCwd(ctx, "ruff");
+    const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
+    if (policy && !policy.preferredRunners.includes("ruff-lint")) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const cmd = await resolveAvailableOrInstall(ruff, "ruff", cwd);
+    if (!cmd) {
+      return { status: "skipped", diagnostics: [], semantic: "none" };
+    }
+    const configArgs = ruffConfigArgs(cwd);
+    const checkResult = await safeSpawnAsync(cmd, ["check", "--output-format", "json", ...configArgs, ctx.filePath], { cwd, timeout: 30000 });
+    const raw = stripAnsi(checkResult.stdout + checkResult.stderr);
+    const run = parseToolRun("ruff", { result: checkResult, output: raw, exitCodes: { ran: [1, 2] } }, (output) => {
+      const diagnostics = parseRuffJson(output, ctx.filePath);
+      return diagnostics.length > 0 ? diagnostics : parseRuffOutput(output, ctx.filePath, cwd);
+    });
+    if (run.skipped)
+      return run.skipped;
+    return finishParsedRun({
+      tool: "ruff",
+      ctx,
+      result: checkResult,
+      diagnostics: run.diagnostics
+    });
+  }
+};
+export default ruffRunner;