@duckmind/dm-linux-x64 0.65.8 → 0.66.2

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

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

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

@@ -1,79 +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 { 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

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