@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

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

@@ -0,0 +1,170 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  createAvailabilityProbeFlight,
+  probeToolAsync
+} from "./chunk-EOKRQ3SA.js";
+import {
+  classifyProbeFailure,
+  createAvailabilityLatch,
+  logAvailabilityDecision,
+  startHostStallSampler
+} from "./chunk-WONERJTP.js";
+import {
+  createGenerationSource
+} from "./chunk-VN2AXLEX.js";
+import {
+  createSingleFlight
+} from "./chunk-BW5KFIQC.js";
+
+// dist/clients/dispatch/runners/utils/candidate-probe.js
+import * as fs from "node:fs";
+async function probeAvailabilityCandidates(candidates, probeArgs, timeoutMs) {
+  let sawTransient = false;
+  let transientCause = "probe-timeout";
+  let hostStallMs = 0;
+  let evidence;
+  for (const candidate of candidates) {
+    try {
+      if (candidate.includes("\\") || candidate.includes("/")) {
+        if (fs.existsSync(candidate)) {
+          return {
+            foundPath: candidate,
+            sawTransient,
+            transientCause,
+            hostStallMs,
+            evidence
+          };
+        }
+        continue;
+      }
+      const sampler = startHostStallSampler();
+      let result;
+      let stallMs;
+      try {
+        result = await probeToolAsync(candidate, probeArgs, {
+          timeout: timeoutMs
+        });
+      } finally {
+        stallMs = sampler.stop();
+        hostStallMs += stallMs;
+      }
+      if (!result.error && result.status === 0) {
+        return {
+          foundPath: candidate,
+          sawTransient,
+          transientCause,
+          hostStallMs,
+          evidence
+        };
+      }
+      const classified = classifyProbeFailure(result, {
+        hostStallMs: stallMs,
+        command: candidate
+      });
+      evidence = classified.evidence;
+      if (classified.outcome === "transient") {
+        sawTransient = true;
+        transientCause = classified.cause;
+      }
+    } catch {
+    }
+  }
+  return {
+    foundPath: null,
+    sawTransient,
+    transientCause,
+    hostStallMs,
+    evidence
+  };
+}
+
+// dist/clients/dispatch/runners/utils/toolchain-availability.js
+var toolchainGenerations = createGenerationSource("toolchain-availability");
+var toolchainProbeFlights = createAvailabilityProbeFlight({ generation: toolchainGenerations.current });
+function createToolchainAvailability(config) {
+  const availabilityLatch = createAvailabilityLatch();
+  let toolPath = null;
+  let sweepSawTransient = false;
+  let sweepTransientCause = "probe-timeout";
+  let sweepHostStallMs = 0;
+  let sweepEvidence;
+  const ensureFlight = createSingleFlight({
+    generation: toolchainGenerations.current
+  });
+  async function findPath() {
+    if (toolPath)
+      return toolPath;
+    const paths = process.platform === "win32" ? config.windowsPaths : config.unixPaths;
+    const handle = toolchainGenerations.capture();
+    const shared = toolchainProbeFlights.run(`toolchain:${config.tool}|${config.probeArgs.join("|")}|${config.windowsPaths.join("|")}|${config.unixPaths.join("|")}`, () => probeAvailabilityCandidates(paths, config.probeArgs, config.budgetMs));
+    const sweep = await shared.promise;
+    handle.guardedWrite(`findPath:${config.tool}`, () => {
+      sweepSawTransient = sweep.sawTransient;
+      sweepTransientCause = sweep.transientCause;
+      sweepHostStallMs = sweep.hostStallMs;
+      sweepEvidence = sweep.evidence;
+      if (sweep.foundPath)
+        toolPath = sweep.foundPath;
+    });
+    return sweep.foundPath;
+  }
+  async function resolveAvailability() {
+    const startedAt = Date.now();
+    const handle = toolchainGenerations.capture();
+    const resolvedPath = await findPath();
+    const found = resolvedPath !== null;
+    const superseded = !handle.isCurrent();
+    if (found) {
+      handle.guardedWrite(`latch:${config.tool}`, () => availabilityLatch.noteAvailable());
+      config.log(`${config.label} found: ${resolvedPath}`);
+      logAvailabilityDecision({
+        tool: config.tool,
+        verdict: "available",
+        outcome: "success",
+        cause: "ok",
+        elapsedMs: Date.now() - startedAt,
+        latched: !superseded,
+        hostStallMs: sweepHostStallMs,
+        budgetMs: config.budgetMs,
+        classifiedBy: "probe",
+        ...sweepEvidence !== void 0 && { evidence: sweepEvidence }
+      });
+      return true;
+    }
+    const outcome = sweepSawTransient ? "transient" : "missing";
+    const cause = sweepSawTransient ? sweepTransientCause : "not-found";
+    const retryAfterMs = handle.guardedWrite(`latch:${config.tool}`, () => availabilityLatch.noteUnavailable(outcome, cause)) ?? 0;
+    logAvailabilityDecision({
+      tool: config.tool,
+      verdict: "unavailable",
+      outcome,
+      cause,
+      elapsedMs: Date.now() - startedAt,
+      latched: !superseded && outcome !== "transient",
+      hostStallMs: sweepHostStallMs,
+      ...retryAfterMs > 0 && { retryAfterMs },
+      budgetMs: config.budgetMs,
+      // Derived from the sweep's own candidate probes, and carrying what the
+      // last of them returned (#1500).
+      classifiedBy: "probe",
+      ...sweepEvidence !== void 0 && { evidence: sweepEvidence }
+    });
+    return false;
+  }
+  async function isAvailable() {
+    const memo = availabilityLatch.read();
+    if (memo !== null)
+      return memo;
+    return ensureFlight.run("availability", resolveAvailability);
+  }
+  function reset() {
+    toolPath = null;
+    availabilityLatch.reset();
+    toolchainGenerations.bump();
+  }
+  return { findPath, isAvailable, reset };
+}
+
+export {
+  createToolchainAvailability
+};

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

@@ -0,0 +1,12 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/clients/sanitize.js
+var ANSI_ESCAPE = /\x1b\[[0-9;]*m/g;
+var ANSI_ESCAPE_EXTENDED = /\x1b\[[0-9;?]*[ -/]*[@-~]/g;
+function stripAnsi(text) {
+  return text.replace(ANSI_ESCAPE, "").replace(ANSI_ESCAPE_EXTENDED, "");
+}
+
+export {
+  stripAnsi
+};

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

@@ -0,0 +1,32 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  CALL_GRAPH_CACHE_VERSION,
+  buildCallGraph,
+  formatImpact,
+  impact,
+  loadCallGraph,
+  parseSymbolKey,
+  saveCallGraph
+} from "./chunk-NKOUFPQF.js";
+import "./chunk-3MED75HT.js";
+import "./chunk-VN2AXLEX.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 {
+  CALL_GRAPH_CACHE_VERSION,
+  buildCallGraph,
+  formatImpact,
+  impact,
+  loadCallGraph,
+  parseSymbolKey,
+  saveCallGraph
+};

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

@@ -0,0 +1,146 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  recordDegradationOnce
+} from "./chunk-N3YQJI6O.js";
+
+// dist/clients/deadline-utils.js
+function combineAbortSignals(...signals) {
+  const live = signals.filter((s) => s !== void 0);
+  if (live.length <= 1)
+    return live[0];
+  if (typeof AbortSignal.any === "function")
+    return AbortSignal.any(live);
+  const controller = new AbortController();
+  for (const s of live) {
+    if (s.aborted) {
+      controller.abort(s.reason);
+      break;
+    }
+    s.addEventListener("abort", () => controller.abort(s.reason), {
+      once: true
+    });
+  }
+  return controller.signal;
+}
+function withDeadline(promise, options) {
+  const onTimeout = options.onTimeout ?? "reject";
+  const onReject = options.onReject ?? "propagate";
+  const ms = options.ms ?? (options.deadlineAt !== void 0 ? options.deadlineAt - Date.now() : 0);
+  if (ms <= 0) {
+    promise.catch(() => {
+    });
+    return onTimeout === "undefined" ? Promise.resolve(void 0) : Promise.reject(new Error(`Timeout after ${Math.max(0, ms)}ms`));
+  }
+  const base = onReject === "undefined" ? promise.catch(() => void 0) : promise;
+  if (onReject === "propagate")
+    promise.catch(() => {
+    });
+  let timer;
+  const timeoutPromise = new Promise((resolve, reject) => {
+    timer = setTimeout(() => {
+      if (onTimeout === "undefined")
+        resolve(void 0);
+      else
+        reject(new Error(`Timeout after ${ms}ms`));
+    }, ms);
+  });
+  return Promise.race([base, timeoutPromise]).finally(() => {
+    if (timer)
+      clearTimeout(timer);
+  });
+}
+function withTimeout(promise, timeoutMs) {
+  return withDeadline(promise, { ms: timeoutMs });
+}
+var BOUND_ABORTED = /* @__PURE__ */ Symbol("pi-lens/bounded/aborted");
+async function bounded(promise, options) {
+  const { signal, shutdownSignal, hook, label } = options;
+  const ms = Number.isFinite(options.ms) ? Math.max(0, options.ms) : 0;
+  const startedAt = Date.now();
+  const boxed = promise.then((value) => ({ value }));
+  void boxed.catch(() => {
+  });
+  let cause;
+  let timer;
+  let onCallerAbort;
+  let onShutdownAbort;
+  const abandoned = new Promise((resolve) => {
+    const fire = (reason) => {
+      cause ??= reason;
+      resolve(BOUND_ABORTED);
+    };
+    if (signal?.aborted)
+      return fire("caller-abort");
+    if (shutdownSignal?.aborted)
+      return fire("shutdown");
+    if (ms <= 0)
+      return fire("deadline");
+    timer = setTimeout(() => fire("deadline"), ms);
+    timer.unref?.();
+    onCallerAbort = () => fire("caller-abort");
+    signal?.addEventListener("abort", onCallerAbort, { once: true });
+    if (shutdownSignal) {
+      onShutdownAbort = () => fire("shutdown");
+      shutdownSignal.addEventListener("abort", onShutdownAbort, {
+        once: true
+      });
+    }
+  });
+  try {
+    const settled = await Promise.race([boxed, abandoned]);
+    if (settled !== BOUND_ABORTED)
+      return settled.value;
+    const elapsedMs = Date.now() - startedAt;
+    const fired = cause ?? "deadline";
+    if (fired === "deadline" || fired === "shutdown") {
+      recordDegradationOnce({
+        kind: fired === "deadline" ? "hook-await-exceeded" : "hook-await-abandoned",
+        subject: `${hook}:${label}`,
+        reason: fired === "deadline" ? `exceeded ${ms}ms budget after ${elapsedMs}ms` : `abandoned after ${elapsedMs}ms: session is shutting down (budget ${ms}ms)`,
+        metadata: { hook, label, budgetMs: ms, elapsedMs, cause: fired }
+      });
+    }
+    return void 0;
+  } finally {
+    if (timer !== void 0)
+      clearTimeout(timer);
+    if (onCallerAbort)
+      signal?.removeEventListener("abort", onCallerAbort);
+    if (onShutdownAbort) {
+      shutdownSignal?.removeEventListener("abort", onShutdownAbort);
+    }
+  }
+}
+
+// dist/clients/hook-budgets.js
+var HOOK_WALL_BUDGET_MS = Object.freeze({
+  /** Visible startup work; the user is watching a progress line. */
+  session_start: 5e3,
+  /** Pure bookkeeping — nothing here may await (#2523 contract). */
+  turn_start: 0,
+  /** Measured p50 3687 ms / p90 14246 ms today. The gap IS the issue. */
+  turn_end: 3e3,
+  /** Measured p90 10043 ms today, from one unbounded pipeline re-entry. */
+  agent_end: 1e3,
+  /** The designated place for settled-time sweeps; the widest non-edit budget. */
+  agent_settled: 1e4,
+  /** Read/Grep/Glob/Bash: must never await analyzer bootstrap (AC5). */
+  tool_result_read_only: 500,
+  /** The ONLY path the contract lets block the host, and only this long. */
+  tool_result_edit: 1e4,
+  /** Teardown: spawning or awaiting here aborts libuv (#234). */
+  session_shutdown: 0,
+  /** Synchronous message contribution; the host is blocked on the answer. */
+  context: 0,
+  /** Fork bookkeeping; the session is being replaced under it. */
+  session_before_fork: 0
+});
+var HOOK_BUDGET_KEYS = Object.keys(HOOK_WALL_BUDGET_MS);
+
+export {
+  combineAbortSignals,
+  withDeadline,
+  withTimeout,
+  bounded,
+  HOOK_WALL_BUDGET_MS
+};

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

@@ -0,0 +1,18 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  collectSourceFiles,
+  collectSourceFilesAsync
+} from "./chunk-6QIUX4EP.js";
+
+// dist/clients/scan-utils.js
+function getSourceFiles(dir, _isTsProject) {
+  return collectSourceFiles(dir);
+}
+function getSourceFilesAsync(dir, _isTsProject) {
+  return collectSourceFilesAsync(dir);
+}
+
+export {
+  getSourceFiles,
+  getSourceFilesAsync
+};