pi-lens 4.2.1 → 4.4.0

package/dist/chunk-4RERDEXR.js

@@ -0,0 +1,348 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  resolveManagedToolClient
+} from "./chunk-7FBF7NPR.js";
+import {
+  biomeConfigArgs
+} from "./chunk-HHYAELLJ.js";
+import "./chunk-B3I2UUT4.js";
+import "./chunk-DIULIWKU.js";
+import "./chunk-VDBPVIKD.js";
+import "./chunk-TGPXLY2J.js";
+import "./chunk-QOZXJ4NA.js";
+import "./chunk-PAK6IDME.js";
+import "./chunk-GUOGVTCQ.js";
+import "./chunk-AJVLWNFN.js";
+import "./chunk-YGVYKNSN.js";
+import "./chunk-LNAKEO63.js";
+import "./chunk-Z3CCVDUB.js";
+import "./chunk-2BEMIWEW.js";
+import "./chunk-OQGFCZJ4.js";
+import {
+  resolveToolCwd
+} from "./chunk-RUOG5D2C.js";
+import {
+  findGlobalBinary
+} from "./chunk-U3VGR4VU.js";
+import "./chunk-NTUJEGDZ.js";
+import {
+  probeToolAsync
+} from "./chunk-EOKRQ3SA.js";
+import {
+  classifyProbeFailure,
+  createAvailabilityLatch,
+  describeInstallAttempt,
+  logAvailabilityDecision,
+  startHostStallSampler
+} from "./chunk-WONERJTP.js";
+import "./chunk-22AVIGXS.js";
+import "./chunk-GVXA6CCE.js";
+import "./chunk-6QIUX4EP.js";
+import "./chunk-VHQLPIRJ.js";
+import {
+  getGlobalPiLensDir,
+  safeSpawnAsync
+} from "./chunk-VN2AXLEX.js";
+import {
+  createSingleFlight
+} from "./chunk-BW5KFIQC.js";
+import "./chunk-QYF5S6P6.js";
+import {
+  isFileKind
+} from "./chunk-5ZEJHV35.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-N3YQJI6O.js";
+import {
+  createSubsystemLogger
+} from "./chunk-O6TQT6RI.js";
+import "./chunk-5THXD6X5.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+
+// dist/clients/biome-client.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var PROBE_TIMEOUT_MS = 1e4;
+var BiomeClient = class {
+  /**
+   * Availability memo, backed by the shared transient-aware latch (#1476).
+   *
+   * Biome is the hot-path formatter: before this, ANY probe failure — a
+   * timeout included — collapsed to `{ outcome: "missing" }`, which both
+   * triggered an install and latched `false` for the life of the process. One
+   * slow first format then disabled formatting until restart.
+   */
+  availabilityLatch = createAvailabilityLatch();
+  /** Cause of the last probe, read when the resolution comes back. */
+  lastProbeCause = null;
+  /**
+   * Measurements of the last failed probe, held until the latch decides how
+   * long the verdict lasts. The decision record is emitted after that, so it
+   * can carry `retryAfterMs` — a latch you can see is worth little if the
+   * retry schedule is not greppable beside it (#1474).
+   */
+  lastProbeElapsedMs = 0;
+  lastProbeHostStallMs = 0;
+  /** Raw facts from the last probe, carried into the decision record (#1500). */
+  lastProbeEvidence;
+  // Per-cwd cache of the resolved biome binary. Keying by cwd matters in
+  // monorepos where different sub-packages each ship their own biome
+  // installation; sharing one slot across the whole client would cause
+  // the first resolution to win and stale across other packages.
+  localBinaryByCwd = /* @__PURE__ */ new Map();
+  // The binary path written by `ensureTool("biome")` — genuinely global
+  // (lives under ~/.pi-lens/tools), so it's stored separately from the
+  // per-cwd cache and used as a final fallback before npx.
+  autoInstalledBinaryPath = null;
+  /**
+   * At-most-one probe/auto-install in flight, via the shared primitive
+   * (#1753). One instance owns one question, so the key is a constant.
+   */
+  ensureFlight = createSingleFlight();
+  log;
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("biome") : () => {
+    };
+  }
+  /**
+   * Resolve the fastest available biome binary for `cwd`.
+   * Prefers local node_modules/.bin/biome (skip npx overhead ~1s).
+   * Falls back to ~/.pi-lens/tools, then npx.
+   *
+   * In monorepos, callers should pass the project / sub-package root for the
+   * edited file (typically `path.dirname(absolutePath)`). Omitting `cwd`
+   * falls back to `process.cwd()`, which is wrong when pi is invoked from
+   * a different directory than the file being edited.
+   */
+  async getBiomeBinary(cwd) {
+    const resolveCwd = cwd ?? process.cwd();
+    const cached = this.localBinaryByCwd.get(resolveCwd);
+    if (cached)
+      return { cmd: cached, args: [] };
+    const isWin = process.platform === "win32";
+    const piLensBin = path.join(getGlobalPiLensDir(), "tools", "node_modules", ".bin");
+    const candidates = isWin ? [
+      path.join(resolveCwd, "node_modules", ".bin", "biome.cmd"),
+      path.join(resolveCwd, "node_modules", ".bin", "biome")
+    ] : [path.join(resolveCwd, "node_modules", ".bin", "biome")];
+    for (const p of candidates) {
+      if (fs.existsSync(p)) {
+        this.localBinaryByCwd.set(resolveCwd, p);
+        return { cmd: p, args: [] };
+      }
+    }
+    if (this.autoInstalledBinaryPath) {
+      return { cmd: this.autoInstalledBinaryPath, args: [] };
+    }
+    const managedCandidates = isWin ? [path.join(piLensBin, "biome.cmd"), path.join(piLensBin, "biome")] : [path.join(piLensBin, "biome")];
+    for (const p of managedCandidates) {
+      if (fs.existsSync(p)) {
+        this.localBinaryByCwd.set(resolveCwd, p);
+        return { cmd: p, args: [] };
+      }
+    }
+    const global = await findGlobalBinary("biome");
+    if (global) {
+      this.localBinaryByCwd.set(resolveCwd, global);
+      return { cmd: global, args: [] };
+    }
+    return { cmd: "npx", args: ["@biomejs/biome"] };
+  }
+  async spawnBiomeAsync(args, timeout = 15e3, cwd) {
+    const { cmd, args: prefix } = await this.getBiomeBinary(cwd);
+    return safeSpawnAsync(cmd, [...prefix, ...args], { timeout, cwd });
+  }
+  /**
+   * Ensure Biome is available, auto-installing if necessary.
+   * Prefer this over isAvailable() for auto-install behavior.
+   *
+   * Re-entrancy safe: concurrent first-time callers share one flight, so
+   * probing/auto-install isn't duplicated. The share and the clear-in-finally
+   * belong to `singleFlight` (#1753); this method owns only the latch
+   * short-circuit above it. #1690 exists because the hand-rolled clear here
+   * was never exercised by a test.
+   *
+   * The memo returns `null` when the last verdict was transient and its
+   * cooldown expired, which re-enters the probe: "biome is not installed" is a
+   * fact worth caching, "the probe timed out" is a moment worth retrying.
+   */
+  async ensureAvailable() {
+    const memo = this.availabilityLatch.read();
+    if (memo !== null)
+      return memo;
+    return this.ensureFlight.run("biome", () => this.doEnsureAvailable());
+  }
+  /**
+   * Probe `biome --version` and classify the failure through the shared
+   * policy. Only a durable verdict (`missing` / `non-installable`) may reach
+   * the install branch of `resolveManagedToolClient`; a transient one returns
+   * as `transient`, which that seam passes straight back without installing.
+   */
+  async probeBiome() {
+    const sampler = startHostStallSampler();
+    const startedAt = Date.now();
+    let result;
+    let hostStallMs;
+    try {
+      const { cmd, args: prefix } = await this.getBiomeBinary();
+      result = await probeToolAsync(cmd, [...prefix, "--version"], {
+        timeout: PROBE_TIMEOUT_MS
+      });
+    } finally {
+      hostStallMs = sampler.stop();
+    }
+    const elapsedMs = Date.now() - startedAt;
+    if (!result.error && result.status === 0) {
+      this.lastProbeCause = "ok";
+      logAvailabilityDecision({
+        tool: "biome",
+        verdict: "available",
+        outcome: "success",
+        cause: "ok",
+        elapsedMs,
+        latched: true,
+        hostStallMs,
+        budgetMs: PROBE_TIMEOUT_MS,
+        classifiedBy: "probe"
+      });
+      return { outcome: "success", value: true };
+    }
+    const { outcome, cause, evidence } = classifyProbeFailure(result, {
+      hostStallMs,
+      unclassifiedFailureOutcome: "missing"
+    });
+    const failureOutcome = outcome === "success" ? "non-installable" : outcome;
+    this.lastProbeCause = cause;
+    this.lastProbeElapsedMs = elapsedMs;
+    this.lastProbeHostStallMs = hostStallMs;
+    this.lastProbeEvidence = evidence;
+    return { outcome: failureOutcome };
+  }
+  async doEnsureAvailable() {
+    const resolved = await resolveManagedToolClient({
+      toolId: "biome",
+      cwd: process.cwd(),
+      probe: () => this.probeBiome(),
+      acceptInstalled: (installedPath) => {
+        this.autoInstalledBinaryPath = installedPath;
+        return true;
+      }
+    });
+    if (resolved.outcome === "success") {
+      this.availabilityLatch.noteAvailable();
+      if (this.lastProbeCause !== null && this.lastProbeCause !== "ok") {
+        logAvailabilityDecision({
+          tool: "biome",
+          verdict: "available",
+          outcome: "success",
+          cause: "ok",
+          elapsedMs: this.lastProbeElapsedMs,
+          latched: true,
+          hostStallMs: this.lastProbeHostStallMs,
+          budgetMs: PROBE_TIMEOUT_MS,
+          classifiedBy: "caller",
+          evidence: {
+            install: "succeeded",
+            binary: "biome",
+            source: "managed-dir"
+          }
+        });
+      }
+      return true;
+    }
+    const cause = this.lastProbeCause ?? "not-found";
+    const retryAfterMs = this.availabilityLatch.noteUnavailable(resolved.outcome, cause);
+    let installEvidence;
+    if (resolved.outcome === "missing") {
+      const { getInstallAttempt } = await import("./probes/installer.js");
+      installEvidence = describeInstallAttempt(getInstallAttempt("biome"));
+    }
+    const evidence = { ...this.lastProbeEvidence, ...installEvidence };
+    logAvailabilityDecision({
+      tool: "biome",
+      verdict: "unavailable",
+      outcome: resolved.outcome,
+      cause,
+      elapsedMs: this.lastProbeElapsedMs,
+      latched: resolved.outcome !== "transient",
+      hostStallMs: this.lastProbeHostStallMs,
+      ...retryAfterMs > 0 && { retryAfterMs },
+      budgetMs: PROBE_TIMEOUT_MS,
+      // Per arm: a probe-derived verdict says `probe`, while a verdict asserted
+      // by the install seam — or a cause that fell back because no probe ran —
+      // says `caller`.
+      classifiedBy: this.lastProbeCause === null || resolved.outcome === "non-installable" ? "caller" : "probe",
+      ...Object.keys(evidence).length > 0 && { evidence }
+    });
+    if (resolved.outcome === "transient") {
+      this.log("biome availability probe timed out; will retry (not installing)");
+    }
+    return false;
+  }
+  /**
+   * Check if a file is supported by Biome
+   */
+  isSupportedFile(filePath) {
+    return isFileKind(filePath, ["jsts", "json", "css"]);
+  }
+  /**
+   * Async auto-fix variant for pipeline use (non-blocking spawn).
+   * `cwd` is the dispatch language root (used for config discovery); when
+   * omitted it defaults to the file's directory.
+   */
+  async fixFileAsync(filePath, cwd) {
+    if (!await this.ensureAvailable()) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: "Biome not available"
+      };
+    }
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: "File not found"
+      };
+    }
+    try {
+      const before = await fs.promises.readFile(absolutePath, "utf-8");
+      const configCwd = resolveToolCwd("runner", "biome", absolutePath, {
+        ...cwd !== void 0 && { cwd }
+      }).cwd;
+      const result = await this.spawnBiomeAsync(["lint", "--write", ...biomeConfigArgs(configCwd), absolutePath], 15e3, configCwd);
+      if (result.error) {
+        return {
+          success: false,
+          changed: false,
+          fixed: 0,
+          error: result.error.message
+        };
+      }
+      const after = await fs.promises.readFile(absolutePath, "utf-8");
+      const changed = before !== after;
+      if (changed) {
+        this.log(`Fixed issue(s) in ${path.basename(filePath)}`);
+      }
+      return { success: true, changed, fixed: changed ? 1 : 0 };
+    } catch (err) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: err instanceof Error ? err.message : String(err)
+      };
+    }
+  }
+};
+export {
+  BiomeClient
+};

package/dist/chunk-4W2PLC4J.js

@@ -0,0 +1,27 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  RustClient,
+  resetRustAvailability,
+  rustClient
+} from "./chunk-RPD5K5NC.js";
+import "./chunk-F3P7VQ7H.js";
+import "./chunk-EOKRQ3SA.js";
+import "./chunk-WONERJTP.js";
+import "./chunk-VN2AXLEX.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-N3YQJI6O.js";
+import "./chunk-O6TQT6RI.js";
+import "./chunk-5THXD6X5.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  RustClient,
+  resetRustAvailability,
+  rustClient
+};

package/dist/chunk-52H5B5TC.js

@@ -0,0 +1,202 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  createAvailabilityChecker,
+  resolveAvailableOrInstall
+} from "./chunk-7FBF7NPR.js";
+import {
+  ruffConfigArgs
+} from "./chunk-HHYAELLJ.js";
+import "./chunk-B3I2UUT4.js";
+import "./chunk-DIULIWKU.js";
+import "./chunk-VDBPVIKD.js";
+import "./chunk-TGPXLY2J.js";
+import "./chunk-QOZXJ4NA.js";
+import "./chunk-PAK6IDME.js";
+import "./chunk-GUOGVTCQ.js";
+import "./chunk-AJVLWNFN.js";
+import "./chunk-YGVYKNSN.js";
+import "./chunk-LNAKEO63.js";
+import "./chunk-Z3CCVDUB.js";
+import "./chunk-2BEMIWEW.js";
+import "./chunk-OQGFCZJ4.js";
+import {
+  resolveToolCwd
+} from "./chunk-RUOG5D2C.js";
+import "./chunk-U3VGR4VU.js";
+import "./chunk-NTUJEGDZ.js";
+import "./chunk-EOKRQ3SA.js";
+import "./chunk-WONERJTP.js";
+import "./chunk-22AVIGXS.js";
+import "./chunk-GVXA6CCE.js";
+import "./chunk-6QIUX4EP.js";
+import "./chunk-VHQLPIRJ.js";
+import {
+  safeSpawnAsync
+} from "./chunk-VN2AXLEX.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-QYF5S6P6.js";
+import {
+  isFileKind
+} from "./chunk-5ZEJHV35.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-N3YQJI6O.js";
+import {
+  createSubsystemLogger
+} from "./chunk-O6TQT6RI.js";
+import "./chunk-5THXD6X5.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import {
+  pathsEqual
+} from "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+
+// dist/clients/ruff-client.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+var ruffAvailability = createAvailabilityChecker("ruff", ".exe");
+var RuffClient = class {
+  ruffCommand = "ruff";
+  log;
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("ruff") : () => {
+    };
+  }
+  /**
+   * Check if ruff CLI is available, auto-install if not.
+   *
+   * Re-entrancy safe: the shared availability seam deduplicates the complete
+   * probe/auto-install transaction per cwd and tool, so concurrent callers do
+   * not duplicate installation attempts.
+   */
+  async ensureAvailable() {
+    const resolved = await resolveAvailableOrInstall(ruffAvailability, "ruff", process.cwd());
+    if (!resolved)
+      return false;
+    this.ruffCommand = resolved;
+    return true;
+  }
+  /**
+   * Check if a file is a Python file
+   */
+  isPythonFile(filePath) {
+    return isFileKind(filePath, "python");
+  }
+  /**
+   * Async auto-fix variant for pipeline use (non-blocking spawn).
+   * `cwd` is the dispatch language root. It is the seam's starting point,
+   * not the answer: `resolveToolCwd` walks from the file to the nearest
+   * `pyproject.toml`/`ruff.toml`/`.ruff.toml` at or above it, capped inside
+   * `cwd` (and at `$HOME` when there is none), so a file in a nested package
+   * gets that package's config rather than the workspace-root one.
+   */
+  async fixFileAsync(filePath, cwd) {
+    if (!await this.ensureAvailable()) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: "Ruff not available"
+      };
+    }
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+      return {
+        success: false,
+        changed: false,
+        fixed: 0,
+        error: "File not found"
+      };
+    }
+    try {
+      const before = await fs.promises.readFile(absolutePath, "utf-8");
+      const ruffCwd = resolveToolCwd("runner", "ruff", absolutePath, {
+        ...cwd !== void 0 && { cwd }
+      }).cwd;
+      const configArgs = ruffConfigArgs(ruffCwd);
+      const pre = await safeSpawnAsync(this.ruffCommand, [
+        "check",
+        "--output-format",
+        "json",
+        "--target-version",
+        "py310",
+        ...configArgs,
+        absolutePath
+      ], { timeout: 1e4, cwd: ruffCwd });
+      const beforeDiags = pre.stdout?.trim() ? this.parseOutput(pre.stdout, ruffCwd, absolutePath) : [];
+      const fixableCount = beforeDiags.filter((d) => d.fixable).length;
+      const fix = await safeSpawnAsync(this.ruffCommand, ["check", "--fix", ...configArgs, absolutePath], { timeout: 15e3, cwd: ruffCwd });
+      if (fix.error) {
+        return {
+          success: false,
+          changed: false,
+          fixed: 0,
+          error: fix.error.message
+        };
+      }
+      const after = await fs.promises.readFile(absolutePath, "utf-8");
+      const changed = before !== after;
+      if (changed) {
+        this.log(`Fixed ${fixableCount} issue(s) in ${path.basename(filePath)}`);
+      }
+      return { success: true, changed, fixed: fixableCount };
+    } catch (err) {
+      return { success: false, changed: false, fixed: 0, error: err.message };
+    }
+  }
+  // --- Internal ---
+  /**
+   * `cwd` is the directory ruff RAN in, and it is REQUIRED: a default would
+   * hide the wrong base at a call site that forgot it (#3284's D11).
+   *
+   * ruff's JSON `filename` is the `SourceFile`'s name verbatim — the JSON
+   * renderer reads `span.file().path(resolver)` (ruff 0.16.8
+   * `crates/ruff_db/src/diagnostic/render/json.rs:58,120`), which for a ruff
+   * (not `ty`) diagnostic is `file.name()` (`crates/ruff_db/src/diagnostic/
+   * mod.rs:1187-1193`), NOT the cwd-relative `relative_path` the text
+   * renderers use (`mod.rs:1195-1204`). That name is
+   * `SourceFileBuilder::new(path.to_string_lossy(), …)`
+   * (`crates/ruff_linter/src/linter.rs:1049`) over a path the resolver has
+   * already absolutized ("Normalize every path (e.g., convert from relative to
+   * absolute)", `crates/ruff_workspace/src/resolver.rs:484`). So ruff echoes
+   * the absolute path we hand it as argv: the BASE was already right here and
+   * the fold deletes a `path.resolve` with no base — which silently meant the
+   * EXTENSION's `process.cwd()`, not ruff's — rather than leaving it for a
+   * future relative invocation to re-enable.
+   */
+  parseOutput(output, cwd, filterFile) {
+    if (!output.trim())
+      return [];
+    try {
+      const items = JSON.parse(output);
+      const diagnostics = [];
+      for (const item of items) {
+        if (filterFile && !pathsEqual(path.resolve(cwd, item.filename), filterFile))
+          continue;
+        diagnostics.push({
+          line: item.location.row - 1,
+          // ruff is 1-indexed
+          column: item.location.column - 1,
+          endLine: item.end_location.row - 1,
+          endColumn: item.end_location.column - 1,
+          severity: item.code?.startsWith("E") ? "error" : "warning",
+          message: item.message,
+          rule: item.code || "unknown",
+          file: item.filename,
+          fixable: item.fix !== null
+        });
+      }
+      return diagnostics;
+    } catch (err) {
+      void err;
+      this.log("Failed to parse ruff JSON output");
+      return [];
+    }
+  }
+};
+export {
+  RuffClient
+};

package/dist/chunk-54B42YRX.js

@@ -0,0 +1,27 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  GovulncheckClient,
+  parseGovulncheckJson
+} from "./chunk-NXPS2L6U.js";
+import "./chunk-7F72PXY2.js";
+import "./chunk-I7SPGOWI.js";
+import "./chunk-NTUJEGDZ.js";
+import "./chunk-EOKRQ3SA.js";
+import "./chunk-WONERJTP.js";
+import "./chunk-VN2AXLEX.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-N3YQJI6O.js";
+import "./chunk-O6TQT6RI.js";
+import "./chunk-5THXD6X5.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  GovulncheckClient,
+  parseGovulncheckJson
+};