@herbertgao/pi-extensions 2026.10.1 → 2026.10.3

package/node_modules/pi-lens/dist/chunk-OEX24ECI.js

@@ -0,0 +1,348 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  resolveManagedToolClient
+} from "./chunk-NFXP47RV.js";
+import {
+  biomeConfigArgs
+} from "./chunk-MGIWSROG.js";
+import "./chunk-IQZXOZ7S.js";
+import "./chunk-LNOMA3MP.js";
+import "./chunk-U52SAGRM.js";
+import "./chunk-KJCWXUUS.js";
+import "./chunk-QOZXJ4NA.js";
+import "./chunk-S6AMWKPC.js";
+import "./chunk-F5VLZHUW.js";
+import "./chunk-AXKPQ6ZI.js";
+import "./chunk-7BX5DWSA.js";
+import "./chunk-IUKPRZER.js";
+import "./chunk-Z3CCVDUB.js";
+import "./chunk-2BEMIWEW.js";
+import "./chunk-LD7WFTRX.js";
+import {
+  resolveToolCwd
+} from "./chunk-IUR76K6A.js";
+import {
+  findGlobalBinary
+} from "./chunk-T4QZ6FEH.js";
+import "./chunk-D6YF5HKX.js";
+import {
+  probeToolAsync
+} from "./chunk-CMU4RMJB.js";
+import {
+  classifyProbeFailure,
+  createAvailabilityLatch,
+  describeInstallAttempt,
+  logAvailabilityDecision,
+  startHostStallSampler
+} from "./chunk-O7HZX7CA.js";
+import "./chunk-VYKKMYVT.js";
+import "./chunk-BNKLYOOO.js";
+import "./chunk-USHG4DLH.js";
+import "./chunk-H5EV3VMF.js";
+import {
+  getGlobalPiLensDir,
+  safeSpawnAsync
+} from "./chunk-T54VJRAD.js";
+import {
+  createSingleFlight
+} from "./chunk-BW5KFIQC.js";
+import "./chunk-QYF5S6P6.js";
+import {
+  isFileKind
+} from "./chunk-64LU2OVH.js";
+import "./chunk-N2IRDBZI.js";
+import "./chunk-Z6BB4JLQ.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-7ELY2CSM.js";
+import {
+  createSubsystemLogger
+} from "./chunk-34OCDWOS.js";
+import "./chunk-3PNFWVHT.js";
+import "./chunk-VSMJK3ZJ.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-G3RLJYA2.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/node_modules/pi-lens/dist/chunk-OYOB3ZFG.js

@@ -0,0 +1,78 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  createToolchainAvailability
+} from "./chunk-XHSCVSOL.js";
+import {
+  createSubsystemLogger
+} from "./chunk-34OCDWOS.js";
+
+// dist/clients/go-client.js
+import * as path from "node:path";
+var GO_WINDOWS_PATHS = [
+  "C:\\Program Files\\Go\\bin\\go.exe",
+  "C:\\Go\\bin\\go.exe",
+  "go.exe"
+  // PATH
+];
+var PROBE_TIMEOUT_MS = 3e3;
+var GO_UNIX_PATHS = [
+  "/usr/local/go/bin/go",
+  "/usr/bin/go",
+  "go"
+  // PATH
+];
+var GoClient = class {
+  /**
+   * Availability lifecycle, behind the shared transient-aware latch (#1476).
+   * The PATH candidate is resolved by spawning `go version` with a 3 s budget,
+   * so a host stall could latch "no Go toolchain" for the whole session and
+   * silently disable every Go diagnostic until restart.
+   */
+  availability;
+  log;
+  constructor(verbose = false) {
+    this.log = verbose ? createSubsystemLogger("go") : () => {
+    };
+    this.availability = createToolchainAvailability({
+      tool: "go",
+      label: "Go",
+      windowsPaths: GO_WINDOWS_PATHS,
+      unixPaths: GO_UNIX_PATHS,
+      probeArgs: ["version"],
+      budgetMs: PROBE_TIMEOUT_MS,
+      log: (msg) => this.log(msg)
+    });
+  }
+  /**
+   * Find go executable path (async — probes PATH candidates off the event loop).
+   */
+  async findGoPathAsync() {
+    return this.availability.findPath();
+  }
+  /**
+   * Check if Go is installed (cached)
+   */
+  async isGoAvailableAsync() {
+    return this.availability.isAvailable();
+  }
+  /**
+   * Check if a file is a Go file
+   */
+  isGoFile(filePath) {
+    return path.extname(filePath).toLowerCase() === ".go";
+  }
+  /** Forget the memoized go path and latched availability verdict — #2455. */
+  resetAvailability() {
+    this.availability.reset();
+  }
+};
+var goClient = new GoClient();
+function resetGoAvailability() {
+  goClient.resetAvailability();
+}
+
+export {
+  GoClient,
+  goClient,
+  resetGoAvailability
+};

package/node_modules/pi-lens/dist/chunk-OYTMZXRF.js

@@ -0,0 +1,41 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  TrivyClient,
+  hasAnyDependencyManifest,
+  isTrivyEnabled,
+  parseTrivyLicenses,
+  parseTrivyReport,
+  parseTrivySecrets,
+  resolveSeverityFloor,
+  shouldScanTrivy,
+  worktreeSkipDirs
+} from "./chunk-YLN4K6WD.js";
+import "./chunk-J3FZR3YY.js";
+import "./chunk-5JHXUETW.js";
+import "./chunk-IMSQR4WO.js";
+import "./chunk-CMU4RMJB.js";
+import "./chunk-O7HZX7CA.js";
+import "./chunk-T54VJRAD.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-N2IRDBZI.js";
+import "./chunk-Z6BB4JLQ.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-7ELY2CSM.js";
+import "./chunk-34OCDWOS.js";
+import "./chunk-3PNFWVHT.js";
+import "./chunk-VSMJK3ZJ.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-G3RLJYA2.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  TrivyClient,
+  hasAnyDependencyManifest,
+  isTrivyEnabled,
+  parseTrivyLicenses,
+  parseTrivyReport,
+  parseTrivySecrets,
+  resolveSeverityFloor,
+  shouldScanTrivy,
+  worktreeSkipDirs
+};

package/node_modules/pi-lens/dist/chunk-OZJINN4O.js

@@ -0,0 +1,84 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  incrementDegradationCount
+} from "./chunk-7ELY2CSM.js";
+import {
+  logLatency
+} from "./chunk-3PNFWVHT.js";
+
+// dist/clients/bounded-telemetry.js
+var MAX_TRACKED_TURN_CAPS = 64;
+var turnCounts = /* @__PURE__ */ new Map();
+var latestCountedTurnIndex;
+var retiredThroughTurnIndex = Number.NEGATIVE_INFINITY;
+function admitBounded(phase, identity, options = {}) {
+  try {
+    let isRisingEdge = true;
+    if (options.ledgerKind !== void 0) {
+      isRisingEdge = incrementDegradationCount({
+        kind: options.ledgerKind,
+        subject: identity,
+        reason: options.reason ?? phase
+      });
+    }
+    if (options.risingEdgePer !== void 0 && !isRisingEdge)
+      return false;
+    return admitAgainstTurnCap(phase, options.capPerTurn);
+  } catch {
+    return true;
+  }
+}
+function emitBounded(phase, identity, payload, options = {}) {
+  try {
+    if (!admitBounded(phase, identity, options))
+      return false;
+    logLatency({
+      ...payload,
+      type: payload.type ?? "phase",
+      phase,
+      // `filePath` is what existing latency.log queries filter on, so a site
+      // may keep a coarser one; `metadata.identity` below always carries the
+      // full discriminating identity. Aggregation that loses WHICH subject
+      // is stuck is the failure AGENTS.md names.
+      filePath: payload.filePath ?? identity,
+      metadata: { ...payload.metadata, identity }
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function admitAgainstTurnCap(phase, cap) {
+  if (cap === void 0)
+    return true;
+  if (cap.turnIndex <= retiredThroughTurnIndex)
+    return false;
+  let counts = turnCounts.get(cap.turnIndex);
+  if (!counts) {
+    if (turnCounts.size >= MAX_TRACKED_TURN_CAPS) {
+      const oldestTrackedTurn = Math.min(...turnCounts.keys());
+      if (cap.turnIndex < oldestTrackedTurn)
+        return false;
+      turnCounts.delete(oldestTrackedTurn);
+      retiredThroughTurnIndex = Math.max(retiredThroughTurnIndex, oldestTrackedTurn);
+    }
+    counts = /* @__PURE__ */ new Map();
+    turnCounts.set(cap.turnIndex, counts);
+  }
+  latestCountedTurnIndex = Math.max(latestCountedTurnIndex ?? cap.turnIndex, cap.turnIndex);
+  const used = counts.get(phase) ?? 0;
+  if (used >= cap.limit)
+    return false;
+  counts.set(phase, used + 1);
+  return true;
+}
+function resetBoundedTelemetry() {
+  turnCounts = /* @__PURE__ */ new Map();
+  latestCountedTurnIndex = void 0;
+  retiredThroughTurnIndex = Number.NEGATIVE_INFINITY;
+}
+
+export {
+  emitBounded,
+  resetBoundedTelemetry
+};

package/node_modules/pi-lens/dist/chunk-PCHDGUKT.js

@@ -0,0 +1,23 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  computeImpactCascade,
+  computeTransitiveImpact
+} from "./chunk-WATC3IQR.js";
+import "./chunk-6XX5HCLK.js";
+import "./chunk-S6AMWKPC.js";
+import "./chunk-T54VJRAD.js";
+import "./chunk-N2IRDBZI.js";
+import "./chunk-Z6BB4JLQ.js";
+import "./chunk-2EECBNC5.js";
+import "./chunk-7ELY2CSM.js";
+import "./chunk-34OCDWOS.js";
+import "./chunk-3PNFWVHT.js";
+import "./chunk-VSMJK3ZJ.js";
+import "./chunk-LJDODBBZ.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-G3RLJYA2.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  computeImpactCascade,
+  computeTransitiveImpact
+};