@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

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

@@ -0,0 +1,309 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  logLatency
+} from "./chunk-5THXD6X5.js";
+
+// dist/clients/dispatch/runners/utils/availability-policy.js
+function describeProbeEvidence(result, command) {
+  const errno = result.error?.code;
+  return {
+    ...command !== void 0 && { command },
+    ...result.status !== void 0 && { status: result.status },
+    ...result.failure !== void 0 && { failure: result.failure },
+    ...result.spawnFailure?.kind !== void 0 && {
+      spawnFailureKind: result.spawnFailure.kind
+    },
+    ...errno !== void 0 && { errno }
+  };
+}
+function describeInstallAttempt(attempt, options = {}) {
+  const reason = attempt?.reason?.slice(0, 200);
+  if (options.installedButRejected) {
+    return {
+      install: "succeeded",
+      installReason: reason ?? "installed binary failed validation"
+    };
+  }
+  if (attempt === void 0)
+    return { install: "not-attempted" };
+  switch (attempt.outcome) {
+    case "succeeded":
+      return { install: "succeeded", ...reason && { installReason: reason } };
+    case "failed":
+      return { install: "failed", ...reason && { installReason: reason } };
+    case "unavailable":
+      return {
+        install: "unavailable",
+        ...reason && { installReason: reason }
+      };
+    default:
+      return {
+        install: "not-attempted",
+        ...reason && { installReason: reason }
+      };
+  }
+}
+var TRANSIENT_BASE_COOLDOWN_MS = 3e4;
+var TRANSIENT_MAX_COOLDOWN_MS = 3e5;
+var HOST_STALL_COOLDOWN_MS = 5e3;
+var HOST_STALL_EVIDENCE_MS = 500;
+function isLatchingOutcome(outcome) {
+  return outcome !== "transient";
+}
+function transientRetryDelayMs(attempts, cause, maxCooldownMs = TRANSIENT_MAX_COOLDOWN_MS) {
+  if (cause === "host-stall")
+    return HOST_STALL_COOLDOWN_MS;
+  const exponent = Math.max(0, attempts - 1);
+  return Math.min(maxCooldownMs, TRANSIENT_BASE_COOLDOWN_MS * 2 ** Math.min(exponent, 10));
+}
+var INSTALL_TRANSIENT_BASE_COOLDOWN_MS = 3e5;
+var INSTALL_TRANSIENT_COOLDOWNS_MS = [
+  INSTALL_TRANSIENT_BASE_COOLDOWN_MS,
+  INSTALL_TRANSIENT_BASE_COOLDOWN_MS * 2
+];
+var INSTALL_TRANSIENT_MAX_ATTEMPTS = INSTALL_TRANSIENT_COOLDOWNS_MS.length + 1;
+function installRetryDelayMs(attempts) {
+  return INSTALL_TRANSIENT_COOLDOWNS_MS[Math.max(0, attempts - 1)] ?? 0;
+}
+var installRetryGeneration = 0;
+function resetInstallRetryLatches() {
+  installRetryGeneration += 1;
+}
+function classifyProbeFailure(result, options = {}) {
+  const evidence = describeProbeEvidence(result, options.command);
+  const errorCode = result.error?.code;
+  if (result.spawnFailure?.kind === "tool-not-found") {
+    return { outcome: "missing", cause: "not-found", evidence };
+  }
+  if (result.failure === "timeout" || result.failure === "aborted" || result.failure === "signal" || result.spawnFailure?.kind === "killed" || result.spawnFailure?.kind === "timeout" || errorCode === "EAGAIN" || errorCode === "EBUSY") {
+    const stalled = (options.hostStallMs ?? 0) >= HOST_STALL_EVIDENCE_MS;
+    return {
+      outcome: "transient",
+      cause: stalled ? "host-stall" : "probe-timeout",
+      evidence
+    };
+  }
+  const outcome = options.unclassifiedFailureOutcome ?? "non-installable";
+  return {
+    outcome,
+    cause: outcome === "missing" ? "not-found" : "probe-rejected",
+    evidence
+  };
+}
+function startHostStallSampler(intervalMs = 100) {
+  let stallMs = 0;
+  let last = Date.now();
+  let stopped = false;
+  const timer = setInterval(() => {
+    const now = Date.now();
+    const lateness = now - last - intervalMs;
+    if (lateness > 0)
+      stallMs += lateness;
+    last = now;
+  }, intervalMs);
+  timer?.unref?.();
+  return {
+    stop: () => {
+      if (stopped)
+        return Math.round(stallMs);
+      stopped = true;
+      clearInterval(timer);
+      const tail = Date.now() - last - intervalMs;
+      if (tail > 0)
+        stallMs += tail;
+      return Math.round(stallMs);
+    }
+  };
+}
+function createAvailabilityLatch(options = {}) {
+  let available = null;
+  let outcome = null;
+  let cause = null;
+  let retryAtMs = 0;
+  let transientAttempts = 0;
+  let installAttempts = 0;
+  let installExhausted = false;
+  let installRetryAtMs = 0;
+  let provisional = false;
+  const maxCooldownMs = options.maxCooldownMs ?? TRANSIENT_MAX_COOLDOWN_MS;
+  let installGeneration = installRetryGeneration;
+  function clearVerdict() {
+    available = null;
+    outcome = null;
+    cause = null;
+    retryAtMs = 0;
+    transientAttempts = 0;
+    installAttempts = 0;
+    installExhausted = false;
+    installRetryAtMs = 0;
+    provisional = false;
+  }
+  function syncInstallGeneration() {
+    if (installGeneration === installRetryGeneration)
+      return;
+    installGeneration = installRetryGeneration;
+    if (installExhausted) {
+      clearVerdict();
+      return;
+    }
+    installAttempts = 0;
+    installRetryAtMs = 0;
+  }
+  function effectiveRetryAtMs() {
+    return Math.max(retryAtMs, installRetryAtMs);
+  }
+  return {
+    read() {
+      syncInstallGeneration();
+      if (available === true) {
+        if (provisional && Date.now() >= effectiveRetryAtMs())
+          return null;
+        return true;
+      }
+      if (available !== false)
+        return available;
+      if (installExhausted)
+        return false;
+      if (outcome !== "transient")
+        return false;
+      return Date.now() >= effectiveRetryAtMs() ? null : false;
+    },
+    noteAvailable(nextCause = "ok") {
+      installGeneration = installRetryGeneration;
+      available = true;
+      outcome = "success";
+      cause = nextCause;
+      retryAtMs = 0;
+      transientAttempts = 0;
+      installAttempts = 0;
+      installExhausted = false;
+      installRetryAtMs = 0;
+      provisional = false;
+    },
+    noteProvisionallyAvailable(transientCause) {
+      syncInstallGeneration();
+      available = true;
+      outcome = "success";
+      cause = transientCause;
+      provisional = true;
+      installAttempts = 0;
+      installExhausted = false;
+      installRetryAtMs = 0;
+      transientAttempts += 1;
+      const delay = transientRetryDelayMs(transientAttempts, transientCause, maxCooldownMs);
+      retryAtMs = Date.now() + delay;
+      return delay;
+    },
+    noteUnavailable(nextOutcome, nextCause, opts) {
+      syncInstallGeneration();
+      available = false;
+      outcome = nextOutcome;
+      cause = nextCause;
+      provisional = false;
+      if (isLatchingOutcome(nextOutcome)) {
+        retryAtMs = 0;
+        installRetryAtMs = 0;
+        return 0;
+      }
+      if (opts?.operationClass === "install") {
+        installAttempts += 1;
+        const installDelay = installRetryDelayMs(installAttempts);
+        if (installDelay === 0) {
+          installExhausted = true;
+          cause = "install-retry-exhausted";
+          retryAtMs = 0;
+          installRetryAtMs = 0;
+          return 0;
+        }
+        installRetryAtMs = Date.now() + installDelay;
+        return installDelay;
+      }
+      transientAttempts += 1;
+      const delay = transientRetryDelayMs(transientAttempts, nextCause, maxCooldownMs);
+      retryAtMs = Date.now() + delay;
+      return delay;
+    },
+    reset() {
+      installGeneration = installRetryGeneration;
+      clearVerdict();
+    },
+    getOutcome: () => outcome,
+    getCause: () => cause,
+    getRetryAtMs: () => effectiveRetryAtMs(),
+    isProvisional: () => provisional,
+    isInstallExhausted: () => {
+      syncInstallGeneration();
+      return installExhausted;
+    }
+  };
+}
+function isTransientDecision(decision) {
+  return decision?.outcome === "transient";
+}
+function describeUnavailability(options) {
+  const { tool, installHint } = options;
+  if (options.outcome !== "transient") {
+    return `${tool} not available. Install with: ${installHint}`;
+  }
+  if (options.cause === "install-retry-exhausted") {
+    return `${tool} install kept timing out and reached its retry ceiling (${INSTALL_TRANSIENT_MAX_ATTEMPTS} attempts). ${tool} is not reported missing \u2014 the install is not being retried again this session, and recovers at the next session. To install it now: ${installHint}`;
+  }
+  const elapsed = options.elapsedMs ? ` after ${options.elapsedMs}ms` : "";
+  const stalled = options.cause === "host-stall" ? " (the pi host event loop stalled during the probe window, so the budget expired on the host side)" : "";
+  const retry = options.retryAfterMs ? ` Retrying in ${Math.round(options.retryAfterMs / 1e3)}s.` : " It will be retried.";
+  return `${tool} availability probe timed out${elapsed}${stalled}. ${tool} is not reported missing \u2014 this is a probe timeout, not a missing install.${retry}`;
+}
+function logAvailabilityDecision(decision, filePath = "<pi-lens>") {
+  logLatency({
+    type: "phase",
+    phase: "availability_decision",
+    filePath,
+    durationMs: Math.round(decision.elapsedMs),
+    metadata: {
+      tool: decision.tool,
+      ...decision.producer !== void 0 && {
+        producer: decision.producer
+      },
+      verdict: decision.verdict,
+      outcome: decision.outcome,
+      cause: decision.cause,
+      latched: decision.latched,
+      ...decision.classifiedBy !== void 0 && {
+        classifiedBy: decision.classifiedBy
+      },
+      // The raw facts sit beside the verdict they produced, so a `missing` row
+      // can be read as justified or not without re-running anything (#1500).
+      ...decision.evidence !== void 0 && { evidence: decision.evidence },
+      ...decision.hostStallMs !== void 0 && {
+        hostStallMs: decision.hostStallMs
+      },
+      ...decision.retryAfterMs !== void 0 && {
+        retryAfterMs: decision.retryAfterMs
+      },
+      ...decision.budgetMs !== void 0 && { budgetMs: decision.budgetMs },
+      ...decision.provisional === true && { provisional: true },
+      ...decision.unreachablePreferred !== void 0 && {
+        unreachablePreferred: decision.unreachablePreferred
+      },
+      ...decision.retained === true && { retained: true },
+      ...decision.servedFromCooldown === true && { servedFromCooldown: true }
+    }
+  });
+}
+
+export {
+  describeProbeEvidence,
+  describeInstallAttempt,
+  TRANSIENT_MAX_COOLDOWN_MS,
+  isLatchingOutcome,
+  transientRetryDelayMs,
+  INSTALL_TRANSIENT_MAX_ATTEMPTS,
+  installRetryDelayMs,
+  resetInstallRetryLatches,
+  classifyProbeFailure,
+  startHostStallSampler,
+  createAvailabilityLatch,
+  isTransientDecision,
+  describeUnavailability,
+  logAvailabilityDecision
+};

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

@@ -0,0 +1,85 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  WORD_INDEX_FORMAT_VERSION,
+  WORD_INDEX_MAX_BYTES,
+  WordIndexQueryError,
+  _resetWordIndexBuildGuardForTests,
+  buildWordIndex,
+  buildWordIndexAsync,
+  buildWordIndexQueryFilter,
+  centralityFromReverseDeps,
+  collectWordIndexDocs,
+  countWordIndexPostingEntries,
+  deserializeWordIndex,
+  estimateWordIndexResidentBytes,
+  flushWordIndexPersistsForTests,
+  flushWordIndexRecompactionsForTests,
+  getLastWordIndexSerializeWork,
+  getWordIndexBuildStatus,
+  getWordIndexWireBytes,
+  parseWordIndexQuery,
+  recordPersistedWordIndexWireBytes,
+  refreshWordIndexIncrementally,
+  removeWordIndexDocument,
+  removeWordIndexDocumentAsync,
+  scheduleWordIndexPersist,
+  searchWordIndex,
+  serializeWordIndex,
+  splitIdentifier,
+  tokenizeLine,
+  triggerBackgroundWordIndexBuild,
+  updateWordIndexDocument,
+  updateWordIndexDocumentAsync,
+  updateWordIndexDocumentForEdit,
+  wordIndexKey,
+  wordIndexPostingHits
+} from "./chunk-YGVYKNSN.js";
+import "./chunk-LNAKEO63.js";
+import "./chunk-Z3CCVDUB.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-QYF5S6P6.js";
+import "./chunk-5ZEJHV35.js";
+import "./chunk-DQ2NZ7C4.js";
+import "./chunk-VNMT7C64.js";
+import "./chunk-N3YQJI6O.js";
+import "./chunk-O6TQT6RI.js";
+import "./chunk-5THXD6X5.js";
+import "./chunk-UK3CMEAL.js";
+import "./chunk-ABBOA7UD.js";
+import "./chunk-Q5U6FMDI.js";
+import "./chunk-NXL4FFQQ.js";
+export {
+  WORD_INDEX_FORMAT_VERSION,
+  WORD_INDEX_MAX_BYTES,
+  WordIndexQueryError,
+  _resetWordIndexBuildGuardForTests,
+  buildWordIndex,
+  buildWordIndexAsync,
+  buildWordIndexQueryFilter,
+  centralityFromReverseDeps,
+  collectWordIndexDocs,
+  countWordIndexPostingEntries,
+  deserializeWordIndex,
+  estimateWordIndexResidentBytes,
+  flushWordIndexPersistsForTests,
+  flushWordIndexRecompactionsForTests,
+  getLastWordIndexSerializeWork,
+  getWordIndexBuildStatus,
+  getWordIndexWireBytes,
+  parseWordIndexQuery,
+  recordPersistedWordIndexWireBytes,
+  refreshWordIndexIncrementally,
+  removeWordIndexDocument,
+  removeWordIndexDocumentAsync,
+  scheduleWordIndexPersist,
+  searchWordIndex,
+  serializeWordIndex,
+  splitIdentifier,
+  tokenizeLine,
+  triggerBackgroundWordIndexBuild,
+  updateWordIndexDocument,
+  updateWordIndexDocumentAsync,
+  updateWordIndexDocumentForEdit,
+  wordIndexKey,
+  wordIndexPostingHits
+};

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

@@ -0,0 +1,27 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/clients/map-with-concurrency.js
+async function mapWithConcurrency(items, concurrency, mapper, signal) {
+  if (items.length === 0)
+    return [];
+  let nextIndex = 0;
+  const workerCount = Math.max(1, Math.min(concurrency, items.length));
+  const results = /* @__PURE__ */ new Map();
+  const worker = async () => {
+    while (true) {
+      if (signal?.aborted)
+        return;
+      const index = nextIndex++;
+      if (index >= items.length)
+        return;
+      results.set(index, await mapper(items[index]));
+    }
+  };
+  const workers = Array.from({ length: workerCount }, () => worker());
+  await Promise.all(workers);
+  return [...results.entries()].sort(([left], [right]) => left - right).map(([, result]) => result);
+}
+
+export {
+  mapWithConcurrency
+};

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

@@ -0,0 +1,144 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  ALL_FORMATTERS,
+  FORMATTERS_WITH_EXPLICIT_CONFIG_CHECK,
+  FORMATTER_AGREEMENT_UNAVAILABLE,
+  FORMATTER_UNAVAILABLE,
+  SKIP_FORMATTING,
+  _findUpForTests,
+  _getFormatterResetStateForTests,
+  biomeFormatter,
+  blackFormatter,
+  clangFormatFormatter,
+  clearFormatterCache,
+  clearFormatterRuntimeState,
+  cljfmtFormatter,
+  cmakeFormatFormatter,
+  csharpierFormatter,
+  cueFormatter,
+  dartFormatter,
+  diagnosticTail,
+  fantomasFormatter,
+  firstDiagnosticLine,
+  formatFile,
+  getFormattersForFile,
+  gleamFormatter,
+  gofmtFormatter,
+  googleJavaFormatFormatter,
+  invalidateFormatterCacheForPath,
+  ktfmtFormatter,
+  ktlintFormatter,
+  listAllFormatters,
+  mixFormatter,
+  nixfmtFormatter,
+  ocamlformatFormatter,
+  ormoluFormatter,
+  oxfmtFormatter,
+  phpCsFixerFormatter,
+  prettierFormatter,
+  psscriptanalyzerFormatFormatter,
+  resolveFormatterCwd,
+  rubocopFormatter,
+  ruffFormatter,
+  rustfmtFormatter,
+  shfmtFormatter,
+  sqlfluffFormatter,
+  standardrbFormatter,
+  styluaFormatter,
+  swiftformatFormatter,
+  taploFormatter,
+  terraformFormatter,
+  terragruntHclFormatter,
+  tryLazyInstallFormatterTool,
+  typstyleFormatter,
+  zigFormatter
+} from "./chunk-F3AU2TMM.js";
+import "./chunk-C2AUYXQH.js";
+import "./chunk-FC4RP4I2.js";
+import "./chunk-HHYAELLJ.js";
+import "./chunk-QOZXJ4NA.js";
+import "./chunk-PAK6IDME.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 "./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 "./chunk-VN2AXLEX.js";
+import "./chunk-BW5KFIQC.js";
+import "./chunk-QYF5S6P6.js";
+import "./chunk-5ZEJHV35.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 {
+  ALL_FORMATTERS,
+  FORMATTERS_WITH_EXPLICIT_CONFIG_CHECK,
+  FORMATTER_AGREEMENT_UNAVAILABLE,
+  FORMATTER_UNAVAILABLE,
+  SKIP_FORMATTING,
+  _findUpForTests,
+  _getFormatterResetStateForTests,
+  biomeFormatter,
+  blackFormatter,
+  clangFormatFormatter,
+  clearFormatterCache,
+  clearFormatterRuntimeState,
+  cljfmtFormatter,
+  cmakeFormatFormatter,
+  csharpierFormatter,
+  cueFormatter,
+  dartFormatter,
+  diagnosticTail,
+  fantomasFormatter,
+  firstDiagnosticLine,
+  formatFile,
+  getFormattersForFile,
+  gleamFormatter,
+  gofmtFormatter,
+  googleJavaFormatFormatter,
+  invalidateFormatterCacheForPath,
+  ktfmtFormatter,
+  ktlintFormatter,
+  listAllFormatters,
+  mixFormatter,
+  nixfmtFormatter,
+  ocamlformatFormatter,
+  ormoluFormatter,
+  oxfmtFormatter,
+  phpCsFixerFormatter,
+  prettierFormatter,
+  psscriptanalyzerFormatFormatter,
+  resolveFormatterCwd,
+  rubocopFormatter,
+  ruffFormatter,
+  rustfmtFormatter,
+  shfmtFormatter,
+  sqlfluffFormatter,
+  standardrbFormatter,
+  styluaFormatter,
+  swiftformatFormatter,
+  taploFormatter,
+  terraformFormatter,
+  terragruntHclFormatter,
+  tryLazyInstallFormatterTool,
+  typstyleFormatter,
+  zigFormatter
+};