@herbertgao/pi-extensions 2026.10.1 → 2026.10.3

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

@@ -0,0 +1,406 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  DEFAULT_MAX_OUTPUT_BYTES,
+  writeFileAtomic
+} from "./chunk-2EECBNC5.js";
+import {
+  incrementDegradationCount
+} from "./chunk-7ELY2CSM.js";
+import {
+  normalizeMapKey
+} from "./chunk-G3RLJYA2.js";
+
+// dist/clients/mcp/ipc.js
+import * as crypto from "node:crypto";
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as os from "node:os";
+import * as path from "node:path";
+var WARM_DIAGNOSTICS_SCHEMA_VERSION = 1;
+var WARM_CODE_ACTION_LOOKUP_LIMIT = 6;
+function ipcPathForCwd(cwd, platform = process.platform) {
+  const hash = workspaceHash(cwd, platform);
+  if (platform === "win32") {
+    return `\\\\.\\pipe\\pi-lens-mcp-${hash}`;
+  }
+  return path.join(os.tmpdir(), `pi-lens-mcp-${hash}.sock`);
+}
+function workspaceHash(cwd, platform = process.platform) {
+  const resolved = path.resolve(cwd);
+  const root = platform === "win32" || platform === "darwin" ? resolved.toLowerCase() : resolved;
+  return crypto.createHash("sha256").update(root).digest("hex").slice(0, 16);
+}
+function diagnosticsIpcPathForCwd(cwd, pid, platform = process.platform) {
+  const base = ipcPathForCwd(cwd, platform);
+  if (platform === "win32")
+    return `${base}-diagnostics-${pid}`;
+  return base.replace(/\.sock$/, `-diagnostics-${pid}.sock`);
+}
+function isNoListenerError(error) {
+  const code = error?.code;
+  return code === "ENOENT" || code === "ECONNREFUSED";
+}
+function contentHash(content) {
+  return crypto.createHash("sha256").update(content).digest("hex");
+}
+function requestOverWarmIpc(endpoint, timeoutMs, buildRequest, validate) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve3(value);
+    };
+    const deadlineAt = Date.now() + timeoutMs;
+    const socket = net.createConnection(endpoint);
+    socket.setEncoding("utf8");
+    const timer = setTimeout(() => finish({ available: false, reason: "timeout" }), timeoutMs);
+    timer.unref();
+    socket.on("connect", () => {
+      socket.write(`${JSON.stringify(buildRequest(deadlineAt))}
+`);
+    });
+    socket.on("data", createWarmIpcLineReader((line) => {
+      try {
+        const message = JSON.parse(line);
+        const result = message.result;
+        if (message.error || !result) {
+          finish({ available: false, reason: "ipc-error" });
+          return;
+        }
+        const reason = validate(result, deadlineAt);
+        if (reason === void 0) {
+          finish({ available: true, response: result });
+        } else {
+          finish({ available: false, reason });
+        }
+      } catch {
+        finish({ available: false, reason: "schema-mismatch" });
+      }
+    }, {
+      label: "warm-diagnostics-reply",
+      onOverflow: () => finish({ available: false, reason: "ipc-error" })
+    }));
+    socket.on("error", (error) => finish({
+      available: false,
+      reason: isNoListenerError(error) ? "no-listener" : "ipc-error"
+    }));
+    socket.on("close", () => finish({ available: false, reason: "ipc-error" }));
+  });
+}
+function requestWarmDiagnostics(cwd, incumbentPid, file, content, timeoutMs) {
+  const expectedHash = contentHash(content);
+  return requestOverWarmIpc(diagnosticsIpcPathForCwd(cwd, incumbentPid), timeoutMs, (deadlineAt) => ({
+    route: "diagnostics",
+    version: WARM_DIAGNOSTICS_SCHEMA_VERSION,
+    file,
+    cwd,
+    content,
+    contentHash: expectedHash,
+    deadlineAt
+  }), (result, deadlineAt) => {
+    if (result.route !== "diagnostics" || result.version !== WARM_DIAGNOSTICS_SCHEMA_VERSION) {
+      return "schema-mismatch";
+    }
+    if (!result.fresh || result.inconclusive || result.contentHash !== expectedHash || result.servedAt > deadlineAt) {
+      return "stale-answer";
+    }
+    return void 0;
+  });
+}
+function requestWarmCodeActions(cwd, incumbentPid, file, expectedContentHash, ranges, timeoutMs) {
+  return requestOverWarmIpc(diagnosticsIpcPathForCwd(cwd, incumbentPid), timeoutMs, (deadlineAt) => ({
+    route: "code-actions",
+    version: WARM_DIAGNOSTICS_SCHEMA_VERSION,
+    file,
+    cwd,
+    contentHash: expectedContentHash,
+    ranges,
+    deadlineAt
+  }), (result, deadlineAt) => {
+    if (result.route !== "code-actions" || result.version !== WARM_DIAGNOSTICS_SCHEMA_VERSION || !Array.isArray(result.actions) || result.actions.length !== ranges.length || result.actions.some((actions) => !Array.isArray(actions))) {
+      return "schema-mismatch";
+    }
+    if (result.contentHash !== expectedContentHash || result.servedAt > deadlineAt) {
+      return "stale-answer";
+    }
+    return void 0;
+  });
+}
+var WARM_TURN_END_SCHEMA_VERSION = 2;
+async function requestWarmTurnEnd(cwd, timeoutMs = 55e3) {
+  const startedAt = Date.now();
+  const first = await requestOverWarmIpc(ipcPathForCwd(cwd), timeoutMs, () => ({
+    route: "turn-end",
+    version: WARM_TURN_END_SCHEMA_VERSION,
+    cwd
+  }), (result) => result.route === "turn-end" && result.version === WARM_TURN_END_SCHEMA_VERSION ? void 0 : "schema-mismatch");
+  if (!first.available || !first.response.deliveryId)
+    return first;
+  const remainingMs = timeoutMs - (Date.now() - startedAt);
+  if (remainingMs <= 0)
+    return { available: false, reason: "timeout" };
+  const ack = await requestOverWarmIpc(ipcPathForCwd(cwd), remainingMs, () => ({
+    route: "turn-end-ack",
+    version: WARM_TURN_END_SCHEMA_VERSION,
+    cwd,
+    deliveryId: first.response.deliveryId
+  }), (result) => result.route === "turn-end-ack" && result.acknowledged === true ? void 0 : "ipc-error");
+  return ack.available ? { available: true, response: first.response } : { available: false, reason: ack.reason };
+}
+function turnEndStatusPathForCwd(cwd, platform = process.platform) {
+  return path.join(os.tmpdir(), `pi-lens-turn-end-${workspaceHash(cwd, platform)}.json`);
+}
+function readTurnEndStatus(cwd, platform = process.platform) {
+  try {
+    const raw = fs.readFileSync(turnEndStatusPathForCwd(cwd, platform), "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object")
+      return void 0;
+    return {
+      ran: typeof parsed.ran === "number" ? parsed.ran : 0,
+      skipped: typeof parsed.skipped === "number" ? parsed.skipped : 0,
+      failed: typeof parsed.failed === "number" ? parsed.failed : 0,
+      lastSkipReason: parsed.lastSkipReason,
+      lastRunAt: parsed.lastRunAt,
+      lastSkipAt: parsed.lastSkipAt,
+      lastFailureOperation: parsed.lastFailureOperation,
+      lastFailureReason: parsed.lastFailureReason,
+      lastFailureAt: parsed.lastFailureAt
+    };
+  } catch {
+    return void 0;
+  }
+}
+function recordTurnEndOutcome(cwd, outcome, platform = process.platform) {
+  try {
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const previous = readTurnEndStatus(cwd, platform) ?? {
+      ran: 0,
+      skipped: 0,
+      failed: 0
+    };
+    let next;
+    if ("failed" in outcome) {
+      next = {
+        ...previous,
+        failed: previous.failed + 1,
+        lastFailureOperation: outcome.operation,
+        lastFailureReason: outcome.reason,
+        lastFailureAt: now
+      };
+    } else {
+      next = outcome.ran ? { ...previous, ran: previous.ran + 1, lastRunAt: now } : {
+        ...previous,
+        skipped: previous.skipped + 1,
+        lastSkipReason: outcome.reason,
+        lastSkipAt: now
+      };
+    }
+    writeFileAtomic(turnEndStatusPathForCwd(cwd, platform), `${JSON.stringify(next)}
+`);
+  } catch {
+  }
+}
+function requestWarmAnalyze(cwd, file, timeoutMs = 3e4) {
+  return new Promise((resolve3) => {
+    let settled = false;
+    const finish = (value) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve3(value);
+    };
+    const socket = net.createConnection(ipcPathForCwd(cwd));
+    socket.setEncoding("utf8");
+    const timer = setTimeout(() => {
+      socket.destroy();
+      finish(void 0);
+    }, timeoutMs);
+    timer.unref();
+    socket.on("connect", () => {
+      const request = { file, cwd };
+      socket.write(`${JSON.stringify(request)}
+`);
+    });
+    socket.on("data", createWarmIpcLineReader((line) => {
+      try {
+        const message = JSON.parse(line);
+        finish(message.error ? void 0 : message.result);
+      } catch {
+        finish(void 0);
+      }
+      socket.end();
+    }, {
+      label: "warm-analyze-reply",
+      // `finish` here only clears the timer and resolves — unlike
+      // `requestOverWarmIpc`'s, which destroys the socket itself — so the
+      // peer that misframed would otherwise keep an open connection and
+      // keep writing into a reader that ignores it.
+      onOverflow: () => {
+        socket.destroy();
+        finish(void 0);
+      }
+    }));
+    socket.on("error", () => finish(void 0));
+    socket.on("close", () => finish(void 0));
+  });
+}
+var MAX_FRAMED_LINE_BYTES = DEFAULT_MAX_OUTPUT_BYTES;
+function createWarmIpcLineReader(onLine, options) {
+  let buffer = "";
+  let bufferedBytes = 0;
+  let dispatched = false;
+  let resyncing = false;
+  const overflow = (frameBytes, awaitingNewline) => {
+    buffer = "";
+    bufferedBytes = 0;
+    resyncing = awaitingNewline;
+    if (options.continuous !== true)
+      dispatched = true;
+    incrementDegradationCount({
+      kind: "ipc-frame-overflow",
+      subject: options.label,
+      reason: `discarded ${awaitingNewline ? "an unterminated" : "a complete"} line at ${frameBytes} bytes (limit ${MAX_FRAMED_LINE_BYTES})`,
+      metadata: {
+        limitBytes: MAX_FRAMED_LINE_BYTES,
+        overflowBytes: frameBytes,
+        terminated: !awaitingNewline
+      }
+    });
+    options.onOverflow?.();
+  };
+  return (chunk) => {
+    if (dispatched)
+      return;
+    let from = 0;
+    if (resyncing) {
+      const end = chunk.indexOf("\n");
+      if (end === -1)
+        return;
+      resyncing = false;
+      from = end + 1;
+    }
+    let newline = chunk.indexOf("\n", from);
+    while (newline !== -1) {
+      const segment = chunk.slice(from, newline);
+      from = newline + 1;
+      const frameBytes = bufferedBytes + Buffer.byteLength(segment);
+      if (frameBytes > MAX_FRAMED_LINE_BYTES) {
+        overflow(frameBytes, false);
+        if (dispatched)
+          return;
+        newline = chunk.indexOf("\n", from);
+        continue;
+      }
+      const line = buffer + segment;
+      buffer = "";
+      bufferedBytes = 0;
+      if (options.continuous !== true) {
+        dispatched = true;
+        onLine(line);
+        return;
+      }
+      onLine(line);
+      newline = chunk.indexOf("\n", from);
+    }
+    if (from < chunk.length) {
+      const rest = chunk.slice(from);
+      buffer += rest;
+      bufferedBytes += Buffer.byteLength(rest);
+    }
+    if (bufferedBytes <= MAX_FRAMED_LINE_BYTES)
+      return;
+    overflow(bufferedBytes, true);
+  };
+}
+function createWarmIpcRequestQueue() {
+  let chain = Promise.resolve();
+  return {
+    enqueue(work) {
+      const next = chain.then(work);
+      chain = next.catch(() => void 0);
+      return next;
+    }
+  };
+}
+
+// dist/clients/dispatch/runner-context.js
+import * as fs2 from "node:fs";
+import * as path2 from "node:path";
+function resolveAgainstAncestors(cwd, filePath) {
+  if (path2.isAbsolute(filePath)) {
+    return path2.resolve(filePath);
+  }
+  const normalizedRelative = filePath.replace(/\\/g, "/");
+  const cwdBaseName = path2.basename(path2.resolve(cwd)).replace(/\\/g, "/");
+  if (cwdBaseName && (normalizedRelative === cwdBaseName || normalizedRelative.startsWith(`${cwdBaseName}/`))) {
+    const trimmedRelative = normalizedRelative === cwdBaseName ? "" : normalizedRelative.slice(cwdBaseName.length + 1);
+    const trimmedCandidate = trimmedRelative ? path2.resolve(cwd, trimmedRelative) : path2.resolve(cwd);
+    if (fs2.existsSync(trimmedCandidate)) {
+      return trimmedCandidate;
+    }
+  }
+  const directCandidate = path2.resolve(cwd, filePath);
+  if (fs2.existsSync(directCandidate)) {
+    return directCandidate;
+  }
+  let current = path2.resolve(cwd);
+  const { root } = path2.parse(current);
+  while (current !== root) {
+    const parent = path2.dirname(current);
+    if (parent === current)
+      break;
+    const candidate = path2.resolve(parent, filePath);
+    if (fs2.existsSync(candidate)) {
+      return candidate;
+    }
+    current = parent;
+  }
+  return directCandidate;
+}
+function resolveRunnerPath(cwd, filePath) {
+  return normalizeMapKey(resolveAgainstAncestors(cwd, filePath));
+}
+function toRunnerDisplayPath(cwd, filePath) {
+  const cwdKey = normalizeMapKey(path2.resolve(cwd));
+  const fileKey = resolveRunnerPath(cwd, filePath);
+  const relative2 = path2.relative(cwdKey, fileKey).replace(/\\/g, "/");
+  if (relative2 && relative2 !== "." && !relative2.startsWith("../")) {
+    return relative2;
+  }
+  return fileKey;
+}
+
+// dist/clients/freshness.js
+var MTIME_DRIFT_TOLERANCE_MS = 50;
+function freshnessFromMtime(input) {
+  const tolerance = input.toleranceMs ?? MTIME_DRIFT_TOLERANCE_MS;
+  if (input.mtimeMs === void 0) {
+    return { verdict: "indeterminate", reason: "no-mtime-evidence" };
+  }
+  return input.mtimeMs > input.referenceMs + tolerance ? { verdict: "stale", reason: "modified-after-reference" } : { verdict: "fresh" };
+}
+
+export {
+  resolveRunnerPath,
+  toRunnerDisplayPath,
+  freshnessFromMtime,
+  WARM_CODE_ACTION_LOOKUP_LIMIT,
+  ipcPathForCwd,
+  diagnosticsIpcPathForCwd,
+  contentHash,
+  requestWarmDiagnostics,
+  requestWarmCodeActions,
+  WARM_TURN_END_SCHEMA_VERSION,
+  requestWarmTurnEnd,
+  readTurnEndStatus,
+  recordTurnEndOutcome,
+  requestWarmAnalyze,
+  createWarmIpcLineReader,
+  createWarmIpcRequestQueue
+};

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

@@ -0,0 +1,170 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  createAvailabilityProbeFlight,
+  probeToolAsync
+} from "./chunk-CMU4RMJB.js";
+import {
+  classifyProbeFailure,
+  createAvailabilityLatch,
+  logAvailabilityDecision,
+  startHostStallSampler
+} from "./chunk-O7HZX7CA.js";
+import {
+  createGenerationSource
+} from "./chunk-T54VJRAD.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-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
+};