@duckmind/dm-linux-x64 0.63.9 → 0.64.6

package/extensions/dm-lens/clients/sg-runner.js

@@ -0,0 +1,624 @@
+import { createSubsystemLogger } from "./extension-log.js";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  getSgCommand,
+  resolveManagedToolClient
+} from "./dispatch/runners/utils/runner-helpers.js";
+import { getProjectIgnoreGlobs } from "./file-utils.js";
+import { findGlobalBinary } from "./package-manager.js";
+import { safeSpawnAsync } from "./safe-spawn.js";
+import { truncatedByOutputCap } from "./spawn-output-cap.js";
+import { createSingleFlight } from "./single-flight.js";
+import {
+  classifyProbeFailure,
+  describeInstallAttempt,
+  createAvailabilityLatch,
+  logAvailabilityDecision,
+  startHostStallSampler
+} from "./dispatch/runners/utils/availability-policy.js";
+export function buildBashRunArgs(cmd, allArgs) {
+  return ["-c", '"$0" "$@"', cmd, ...allArgs];
+}
+function sgExcludeArgsForProject(rootDir) {
+  return getProjectIgnoreGlobs(rootDir).flatMap((glob) => [
+    "--globs",
+    `!${glob}`
+  ]);
+}
+const DEFAULT_EXEC_TIMEOUT_MS = 30000;
+const PROBE_TIMEOUT_MS = 5000;
+const MAX_SG_OUTPUT_BYTES = 8 * 1024 * 1024;
+function formatMetaVarCaptures(mv) {
+  if (!mv)
+    return;
+  const parts = [];
+  for (const [name, node] of Object.entries(mv.single)) {
+    if (node.text)
+      parts.push(`$${name}=${node.text}`);
+  }
+  for (const [name, nodes] of Object.entries(mv.multi)) {
+    if (nodes.length > 0) {
+      const joined = nodes.map((n) => n.text).join("");
+      if (joined)
+        parts.push(`$$$${name}=${joined}`);
+    }
+  }
+  for (const [name, value] of Object.entries(mv.transformed)) {
+    if (value)
+      parts.push(`@${name}=${value}`);
+  }
+  if (parts.length === 0)
+    return;
+  return `  ${parts.join("  ")}`;
+}
+function tryParseSgMatches(stdout) {
+  try {
+    const parsed = JSON.parse(stdout);
+    if (Array.isArray(parsed))
+      return parsed;
+    if (parsed !== null && typeof parsed === "object")
+      return [parsed];
+    return null;
+  } catch {
+    return null;
+  }
+}
+function tryParseNonZeroSgMatches(result) {
+  if (!result.stdout.trim())
+    return null;
+  return tryParseSgMatches(result.stdout.trim());
+}
+
+export class SgRunner {
+  log;
+  sgPath = null;
+  sgArgsPrefix = [];
+  availabilityLatch = createAvailabilityLatch();
+  ensureFlight = createSingleFlight();
+  sweepSawTransient = false;
+  sweepTransientCause = "probe-timeout";
+  sweepUnreachable = [];
+  sweepFallbackTransient = false;
+  sweepFallbackCause = "probe-timeout";
+  sweepHostStallMs = 0;
+  sweepDurablyMissing = [];
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("sg-runner") : () => {};
+  }
+  async ensureAvailable() {
+    const memo = this.availabilityLatch.read();
+    if (memo !== null)
+      return memo;
+    return this.ensureFlight.run("ast-grep", () => this.doEnsureAvailable());
+  }
+  async doEnsureAvailable() {
+    const startedAt = Date.now();
+    this.sweepSawTransient = false;
+    this.sweepTransientCause = "probe-timeout";
+    this.sweepUnreachable = [];
+    this.sweepFallbackTransient = false;
+    this.sweepFallbackCause = "probe-timeout";
+    this.sweepHostStallMs = 0;
+    this.sweepDurablyMissing = [];
+    const pathCommand = await this.probeCommandCandidates([
+      { cmd: "ast-grep", argsPrefix: [] },
+      { cmd: "sg", argsPrefix: [] },
+      { cmd: "npx", argsPrefix: ["--no", "--", "ast-grep"], fallback: true }
+    ]);
+    if (pathCommand) {
+      this.sgPath = pathCommand.cmd;
+      this.sgArgsPrefix = pathCommand.argsPrefix;
+      this.noteAvailable(startedAt, `ast-grep found on PATH: ${pathCommand.cmd}`);
+      return true;
+    }
+    for (const name of ["ast-grep", "sg"]) {
+      const globalBin = await findGlobalBinary(name);
+      if (globalBin && await this.probeCommand(globalBin, [])) {
+        this.sgPath = globalBin;
+        this.sgArgsPrefix = [];
+        this.noteAvailable(startedAt, `ast-grep found in global bin: ${globalBin}`);
+        return true;
+      }
+    }
+    const platformBinary = await this.probePlatformPackageBinary();
+    if (platformBinary) {
+      this.sgPath = platformBinary;
+      this.sgArgsPrefix = [];
+      this.noteAvailable(startedAt, `ast-grep found via platform package: ${platformBinary}`);
+      return true;
+    }
+    if (process.platform === "darwin") {
+      const brewBinary = await this.probeHomebrew();
+      if (brewBinary) {
+        this.sgPath = brewBinary;
+        this.sgArgsPrefix = [];
+        this.noteAvailable(startedAt, `ast-grep found via Homebrew: ${brewBinary}`);
+        return true;
+      }
+    }
+    if (this.sweepSawTransient) {
+      if (this.availabilityLatch.isProvisional() && this.sgPath && !this.sweepDurablyMissing.includes(this.sgPath)) {
+        this.noteAvailable(startedAt, `ast-grep re-probe stalled; keeping ${this.sgPath}`, { retained: true });
+        return true;
+      }
+      this.log("ast-grep availability probe timed out; will retry (not installing)");
+      return this.noteUnavailable(startedAt, "transient", this.sweepTransientCause);
+    }
+    const installed = await resolveManagedToolClient({
+      toolId: "ast-grep",
+      cwd: process.cwd(),
+      probe: async () => ({ outcome: "missing" }),
+      acceptInstalled: async (installedPath) => await this.probeCommand(installedPath, []) ? installedPath : null
+    });
+    if (installed.outcome === "success") {
+      this.sgPath = installed.value;
+      this.sgArgsPrefix = [];
+      this.noteAvailable(startedAt, `ast-grep auto-installed: ${installed.value}`);
+      return true;
+    }
+    if (this.sweepFallbackTransient) {
+      return this.noteUnavailable(startedAt, "transient", this.sweepFallbackCause);
+    }
+    const { getInstallAttempt } = await import("./installer/index.js");
+    return this.noteUnavailable(startedAt, "missing", "not-found", describeInstallAttempt(getInstallAttempt("ast-grep"), {
+      installedButRejected: installed.outcome === "non-installable"
+    }), "caller");
+  }
+  noteAvailable(startedAt, message, opts = {}) {
+    const provisional = this.sweepSawTransient;
+    let retryAfterMs = 0;
+    if (provisional) {
+      retryAfterMs = this.availabilityLatch.noteProvisionallyAvailable(this.sweepTransientCause);
+    } else {
+      this.availabilityLatch.noteAvailable();
+    }
+    this.log(message);
+    logAvailabilityDecision({
+      tool: "ast-grep",
+      verdict: "available",
+      outcome: "success",
+      cause: provisional ? this.sweepTransientCause : "ok",
+      elapsedMs: Date.now() - startedAt,
+      latched: !provisional,
+      classifiedBy: "probe",
+      hostStallMs: this.sweepHostStallMs,
+      budgetMs: PROBE_TIMEOUT_MS,
+      ...provisional && {
+        provisional: true,
+        unreachablePreferred: [...this.sweepUnreachable],
+        ...opts.retained === true && { retained: true },
+        ...retryAfterMs > 0 && { retryAfterMs }
+      }
+    });
+  }
+  noteUnavailable(startedAt, outcome, cause, evidence, classifiedBy = "probe") {
+    const retryAfterMs = this.availabilityLatch.noteUnavailable(outcome, cause);
+    logAvailabilityDecision({
+      tool: "ast-grep",
+      verdict: "unavailable",
+      outcome,
+      cause,
+      elapsedMs: Date.now() - startedAt,
+      latched: outcome !== "transient",
+      hostStallMs: this.sweepHostStallMs,
+      ...retryAfterMs > 0 && { retryAfterMs },
+      budgetMs: PROBE_TIMEOUT_MS,
+      classifiedBy,
+      ...evidence !== undefined && { evidence }
+    });
+    return false;
+  }
+  async probePlatformPackageBinary() {
+    const { platform, arch } = process;
+    const exeName = platform === "win32" ? "sg.exe" : "sg";
+    const pkgSuffixes = [];
+    if (platform === "linux" && arch === "x64")
+      pkgSuffixes.push("linux-x64-gnu");
+    if (platform === "linux" && arch === "arm64")
+      pkgSuffixes.push("linux-arm64-gnu");
+    if (platform === "darwin" && arch === "arm64")
+      pkgSuffixes.push("darwin-arm64");
+    if (platform === "darwin" && arch === "x64")
+      pkgSuffixes.push("darwin-x64");
+    if (platform === "win32" && arch === "x64")
+      pkgSuffixes.push("win32-x64-msvc");
+    if (platform === "win32" && arch === "arm64")
+      pkgSuffixes.push("win32-arm64-msvc");
+    const searchRoots = [];
+    let dir = process.cwd();
+    for (let depth = 0;depth < 5; depth++) {
+      searchRoots.push(path.join(dir, "node_modules"));
+      const parent = path.dirname(dir);
+      if (parent === dir)
+        break;
+      dir = parent;
+    }
+    for (const suffix of pkgSuffixes) {
+      const pkgName = `@ast-grep/cli-${suffix}`;
+      for (const root of searchRoots) {
+        const candidate = path.join(root, pkgName, exeName);
+        try {
+          if (fs.existsSync(candidate) && await this.probeCommand(candidate, [])) {
+            return candidate;
+          }
+        } catch {}
+      }
+    }
+    return;
+  }
+  async probeHomebrew() {
+    try {
+      const result = await safeSpawnAsync("brew", ["--prefix", "ast-grep"], {
+        timeout: 3000
+      });
+      if (result.error || result.status !== 0)
+        return;
+      const prefix = result.stdout.trim();
+      if (!prefix)
+        return;
+      for (const name of ["ast-grep", "sg"]) {
+        const candidate = path.join(prefix, "bin", name);
+        if (fs.existsSync(candidate) && await this.probeCommand(candidate, [])) {
+          return candidate;
+        }
+      }
+    } catch {}
+    return;
+  }
+  isAstGrepVersionOutput(output) {
+    return /\bast[- ]grep\b/i.test(output);
+  }
+  async probeCommand(cmd, argsPrefix, fallback = false) {
+    const sampler = startHostStallSampler();
+    let result;
+    let hostStallMs;
+    try {
+      result = await safeSpawnAsync(cmd, [...argsPrefix, "--version"], {
+        timeout: PROBE_TIMEOUT_MS
+      });
+    } finally {
+      hostStallMs = sampler.stop();
+      this.sweepHostStallMs += hostStallMs;
+    }
+    if (!result.error && result.status === 0 && this.isAstGrepVersionOutput(`${result.stdout}
+${result.stderr}`)) {
+      return true;
+    }
+    const { outcome, cause } = classifyProbeFailure(result, { hostStallMs });
+    if (outcome === "transient") {
+      if (fallback) {
+        this.sweepFallbackTransient = true;
+        this.sweepFallbackCause = cause;
+      } else {
+        this.sweepSawTransient = true;
+        this.sweepTransientCause = cause;
+        const name = path.basename(cmd);
+        if (!this.sweepUnreachable.includes(name)) {
+          this.sweepUnreachable.push(name);
+        }
+      }
+    } else if (!this.sweepDurablyMissing.includes(cmd)) {
+      this.sweepDurablyMissing.push(cmd);
+    }
+    return false;
+  }
+  async probeCommandCandidates(candidates) {
+    for (const candidate of candidates) {
+      if (await this.probeCommand(candidate.cmd, candidate.argsPrefix, candidate.fallback ?? false)) {
+        return candidate;
+      }
+    }
+    return;
+  }
+  getSgCommand() {
+    return {
+      cmd: this.sgPath || "ast-grep",
+      argsPrefix: this.sgArgsPrefix
+    };
+  }
+  failureForSpawnResult(result) {
+    if (result.failure === "aborted")
+      return "aborted";
+    switch (result.spawnFailure?.kind) {
+      case "tool-not-found":
+        return "unavailable";
+      case "timeout":
+        return "timeout";
+      case "killed":
+        return result.failure === "aborted" ? "aborted" : "cli-failure";
+      case "cwd-unresolvable":
+      case "permission-denied":
+      case "spawn-failed":
+      case undefined:
+        return result.error ? "cli-failure" : undefined;
+    }
+  }
+  formatPatternError(stderr, args) {
+    if (stderr.includes("Multiple AST nodes are detected")) {
+      return `Invalid AST pattern: The pattern appears to contain multiple AST nodes or is malformed.
+Common causes:
+  1. Missing parentheses: use it($TEST) not it"test"
+  2. Raw text without structure: use console.log($MSG) not just "console.log"
+  3. Unclosed quotes or brackets
+
+Original error: ${stderr}`;
+    }
+    if (stderr.includes("Cannot parse query")) {
+      return `Pattern syntax error: The pattern could not be parsed as valid code.
+Tips:
+  - Patterns must be valid ${args.includes("--lang") ? args[args.indexOf("--lang") + 1] : "language"} syntax
+  - Use metavariables like $NAME, $ARGS for variable parts
+  - Example: 'function $NAME($$$PARAMS) { $$$BODY }'
+
+Original error: ${stderr}`;
+    }
+    return stderr;
+  }
+  async execRaw(args, timeout = DEFAULT_EXEC_TIMEOUT_MS, options = {}) {
+    const command = this.getSgCommand();
+    const result = await safeSpawnAsync(command.cmd, [...command.argsPrefix, ...args], {
+      timeout,
+      deadlineAt: options.deadlineAt,
+      signal: options.signal,
+      maxOutputBytes: MAX_SG_OUTPUT_BYTES
+    });
+    const failure = this.failureForSpawnResult(result);
+    return {
+      stdout: result.stdout,
+      stderr: result.stderr,
+      status: result.status,
+      error: result.error?.message,
+      failure,
+      ...result.outputTruncated ? { outputTruncated: true } : {}
+    };
+  }
+  async exec(args, options = {}) {
+    const command = this.getSgCommand();
+    const allArgs = [...command.argsPrefix, ...args];
+    const isWindows = process.platform === "win32";
+    const hasBash = Boolean(process.env.MSYSTEM || process.env.GIT_SHELL);
+    const useBash = isWindows && hasBash;
+    const result = await safeSpawnAsync(useBash ? "bash" : command.cmd, useBash ? buildBashRunArgs(command.cmd, allArgs) : allArgs, {
+      timeout: DEFAULT_EXEC_TIMEOUT_MS,
+      deadlineAt: options.deadlineAt,
+      signal: options.signal,
+      maxOutputBytes: MAX_SG_OUTPUT_BYTES
+    });
+    const empty = () => ({
+      matches: [],
+      totalMatches: 0,
+      truncated: false
+    });
+    if (truncatedByOutputCap(result)) {
+      return {
+        ...empty(),
+        error: "Failed to parse output: output was truncated"
+      };
+    }
+    const spawnFailure = this.failureForSpawnResult(result);
+    if (spawnFailure) {
+      return {
+        ...empty(),
+        error: spawnFailure === "unavailable" ? "ast-grep CLI not found. Install: npm i -D @ast-grep/cli" : result.error?.message || "ast-grep CLI failed to start"
+      };
+    }
+    if (result.status !== 0) {
+      const stdout = result.stdout.trim();
+      const stderr = result.stderr.trim();
+      if (result.status === 1 && stdout) {
+        const matches = tryParseNonZeroSgMatches(result);
+        if (matches) {
+          return {
+            matches,
+            totalMatches: matches.length,
+            truncated: false
+          };
+        }
+      }
+      if (result.status === 1 && !stdout && !stderr)
+        return empty();
+      return {
+        ...empty(),
+        error: this.formatPatternError(stderr || `Command failed with exit code ${result.status}`, args)
+      };
+    }
+    if (!result.stdout.trim())
+      return empty();
+    {
+      const matches = tryParseSgMatches(result.stdout);
+      if (matches) {
+        return {
+          matches,
+          totalMatches: matches.length,
+          truncated: false
+        };
+      }
+      return { ...empty(), error: "Failed to parse output" };
+    }
+  }
+  prepareTempScan(ruleId, ruleYaml) {
+    const sessionDir = path.join(os.tmpdir(), `dm-lens-temp-${ruleId}-${Date.now()}`);
+    const rulesSubdir = path.join(sessionDir, "rules");
+    const configFile = path.join(sessionDir, ".sgconfig.yml");
+    fs.mkdirSync(rulesSubdir, { recursive: true });
+    fs.writeFileSync(configFile, `ruleDirs:
+  - ./rules
+`);
+    fs.writeFileSync(path.join(rulesSubdir, `${ruleId}.yml`), ruleYaml);
+    return { sessionDir, configFile };
+  }
+  cleanupTempScan(sessionDir) {
+    try {
+      fs.rmSync(sessionDir, { recursive: true, force: true });
+    } catch (err) {
+      this.log(`Cleanup failed: ${err.message}`);
+    }
+  }
+  interpretScanResult(result, args) {
+    if (truncatedByOutputCap(result)) {
+      return {
+        matches: [],
+        status: result.status,
+        error: "Failed to parse ast-grep scan output: output was truncated",
+        failure: "parse-failure"
+      };
+    }
+    const failure = this.failureForSpawnResult(result);
+    if (failure) {
+      return {
+        matches: [],
+        status: result.status,
+        error: result.error?.message || "ast-grep CLI failed to start",
+        failure
+      };
+    }
+    if (result.status !== 0) {
+      const stdout = result.stdout.trim();
+      const stderr = result.stderr.trim();
+      if (result.status === 1 && stdout) {
+        const matches = tryParseNonZeroSgMatches(result);
+        if (matches) {
+          return { matches, status: result.status };
+        }
+      }
+      if (result.status === 1 && !stdout && !stderr) {
+        return { matches: [], status: result.status };
+      }
+      return {
+        matches: [],
+        status: result.status,
+        error: this.formatPatternError(stderr || `ast-grep scan failed with exit code ${result.status}`, args),
+        failure: "cli-failure"
+      };
+    }
+    if (!result.stdout.trim())
+      return { matches: [], status: result.status };
+    {
+      const matches = tryParseSgMatches(result.stdout);
+      if (matches) {
+        return { matches, status: result.status };
+      }
+      return {
+        matches: [],
+        status: result.status,
+        error: "Failed to parse ast-grep scan output: invalid JSON",
+        failure: "parse-failure"
+      };
+    }
+  }
+  async tempScanDetailedAsync(dir, ruleId, ruleYaml, timeout = DEFAULT_EXEC_TIMEOUT_MS, options = {}) {
+    const { sessionDir, configFile } = this.prepareTempScan(ruleId, ruleYaml);
+    try {
+      const { cmd: sgCmd, args: sgPre } = getSgCommand();
+      const result = await safeSpawnAsync(sgCmd, [
+        ...sgPre,
+        "scan",
+        "--config",
+        configFile,
+        "--json",
+        ...sgExcludeArgsForProject(dir),
+        dir
+      ], {
+        timeout,
+        deadlineAt: options.deadlineAt,
+        signal: options.signal,
+        maxOutputBytes: MAX_SG_OUTPUT_BYTES
+      });
+      return this.interpretScanResult(result, ["scan"]);
+    } finally {
+      this.cleanupTempScan(sessionDir);
+    }
+  }
+  async tempScanAsync(dir, ruleId, ruleYaml, timeout = DEFAULT_EXEC_TIMEOUT_MS, options = {}) {
+    const result = await this.tempScanDetailedAsync(dir, ruleId, ruleYaml, timeout, options);
+    return result.matches;
+  }
+  async tempScanWithFixAsync(dir, ruleId, ruleYaml, applyFixes, timeout = DEFAULT_EXEC_TIMEOUT_MS, options = {}) {
+    const { sessionDir, configFile } = this.prepareTempScan(ruleId, ruleYaml);
+    try {
+      const { cmd: sgCmd, args: sgPre } = getSgCommand();
+      const scanArgs = [
+        ...sgPre,
+        "scan",
+        "--config",
+        configFile,
+        "--json",
+        ...sgExcludeArgsForProject(dir),
+        dir
+      ];
+      const spawnOptions = {
+        timeout,
+        deadlineAt: options.deadlineAt,
+        signal: options.signal,
+        maxOutputBytes: MAX_SG_OUTPUT_BYTES
+      };
+      if (!applyFixes) {
+        const result = await safeSpawnAsync(sgCmd, scanArgs, spawnOptions);
+        const scan = this.interpretScanResult(result, ["scan"]);
+        return scan.failure || scan.error ? { matches: [], error: scan.error } : { matches: scan.matches };
+      }
+      const jsonResult = await safeSpawnAsync(sgCmd, scanArgs, spawnOptions);
+      const scan = this.interpretScanResult(jsonResult, ["scan"]);
+      if (scan.failure || scan.error) {
+        return { matches: [], error: scan.error };
+      }
+      const applyResult = await safeSpawnAsync(sgCmd, [
+        ...sgPre,
+        "scan",
+        "--config",
+        configFile,
+        "--update-all",
+        ...sgExcludeArgsForProject(dir),
+        dir
+      ], spawnOptions);
+      if (applyResult.error || applyResult.failure || applyResult.status !== 0) {
+        return {
+          matches: [],
+          error: applyResult.error?.message || `ast-grep apply failed with exit code ${applyResult.status}`
+        };
+      }
+      return { matches: scan.matches };
+    } catch (err) {
+      return { matches: [], error: String(err) };
+    } finally {
+      this.cleanupTempScan(sessionDir);
+    }
+  }
+  formatMatches(matches, isDryRun = false, maxItems = 50, showModeIndicator = false) {
+    if (matches.length === 0) {
+      if (showModeIndicator) {
+        return isDryRun ? "[DRY-RUN] No matches found." : "[NOT APPLIED] No matches found — nothing was changed. Run ast_grep_search to confirm the pattern matches before applying.";
+      }
+      return "No matches found";
+    }
+    const shown = matches.slice(0, maxItems);
+    const lines = shown.map((m) => {
+      const loc = `${m.file}:${m.range.start.line + 1}:${m.range.start.column + 1}`;
+      const text = m.text.length > 100 ? `${m.text.slice(0, 100)}...` : m.text;
+      const langSuffix = m.language ? `  [${m.language}]` : "";
+      const base = isDryRun && m.replacement ? `${loc}
+  - ${text}
+  + ${m.replacement}` : `${loc}: ${text}${langSuffix}`;
+      const captures = formatMetaVarCaptures(m.metaVariables);
+      return captures ? `${base}
+${captures}` : base;
+    });
+    if (matches.length > maxItems) {
+      lines.unshift(`Found ${matches.length} matches (showing first ${maxItems}):`);
+    }
+    if (showModeIndicator) {
+      const prefix = isDryRun ? "[DRY-RUN]" : "[APPLIED]";
+      const suffix = isDryRun ? `
+
+(Dry run — use apply=true to apply changes)` : "";
+      return `${prefix} ${matches.length} replacement(s):
+
+${lines.join(`
+`)}${suffix}`;
+    }
+    return lines.join(`
+`);
+  }
+}