@herbertgao/pi-extensions 2026.10.0 → 2026.10.2

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

@@ -0,0 +1,103 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  stagePathFor
+} from "./chunk-LJDODBBZ.js";
+
+// dist/clients/gzip-stage-write.js
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { parentPort } from "node:worker_threads";
+import { createGzip } from "node:zlib";
+async function writeGzipStageFile(data, stagePath, testDelayMs, options) {
+  const startedAt = performance.now();
+  const tmpPath = stagePathFor(stagePath);
+  try {
+    if (testDelayMs) {
+      await new Promise((resolve) => setTimeout(resolve, testDelayMs));
+    }
+    const serializeStarted = performance.now();
+    const body = data instanceof Uint8Array ? data : JSON.stringify(data);
+    const serializeMs = performance.now() - serializeStarted;
+    const rawBytes = Buffer.byteLength(body);
+    const semanticFingerprint = options?.semanticFingerprint?.(body);
+    if (semanticFingerprint !== void 0 && options?.skipIfFingerprints?.includes(semanticFingerprint)) {
+      return {
+        rawBytes,
+        gzBytes: 0,
+        serializeMs,
+        writeMs: 0,
+        durationMs: performance.now() - startedAt,
+        semanticFingerprint,
+        skippedUnchanged: true
+      };
+    }
+    const writeStarted = performance.now();
+    await fs.promises.mkdir(path.dirname(stagePath), { recursive: true });
+    const chunks = function* () {
+      const chunkSize = 256 * 1024;
+      let offset = 0;
+      while (offset < body.length) {
+        let end = Math.min(offset + chunkSize, body.length);
+        if (typeof body === "string" && end < body.length) {
+          const last = body.charCodeAt(end - 1);
+          if (last >= 55296 && last <= 56319)
+            end--;
+        }
+        yield typeof body === "string" ? body.slice(offset, end) : body.subarray(offset, end);
+        offset = end;
+      }
+    };
+    await pipeline(Readable.from(chunks()), createGzip(), fs.createWriteStream(tmpPath));
+    await fs.promises.rename(tmpPath, stagePath);
+    const writeMs = performance.now() - writeStarted;
+    const gzBytes = (await fs.promises.stat(stagePath)).size;
+    return {
+      rawBytes,
+      gzBytes,
+      serializeMs,
+      writeMs,
+      durationMs: performance.now() - startedAt,
+      semanticFingerprint
+    };
+  } catch (err) {
+    await fs.promises.rm(tmpPath, { force: true }).catch(() => {
+    });
+    throw err;
+  }
+}
+function serveGzipStageWorker(buildBaseResult, options) {
+  const port = parentPort;
+  if (!port) {
+    throw new Error("gzip stage persist worker requires a parent port");
+  }
+  port.on("message", (request) => {
+    void (async () => {
+      const result = {
+        ...buildBaseResult(request)
+      };
+      try {
+        const fingerprint = options?.semanticFingerprint;
+        const metrics = await writeGzipStageFile(request.data, request.stagePath, request.testDelayMs, {
+          semanticFingerprint: fingerprint ? (body) => fingerprint(request, body) : void 0,
+          skipIfFingerprints: options?.skipIfFingerprints?.(request)
+        });
+        result.rawBytes = metrics.rawBytes;
+        result.gzBytes = metrics.gzBytes;
+        result.serializeMs = metrics.serializeMs;
+        result.writeMs = metrics.writeMs;
+        result.durationMs = metrics.durationMs;
+        result.semanticFingerprint = metrics.semanticFingerprint;
+        result.skippedUnchanged = metrics.skippedUnchanged;
+      } catch (err) {
+        result.error = err instanceof Error ? err.message : String(err);
+      }
+      port.postMessage(result);
+    })();
+  });
+}
+
+export {
+  serveGzipStageWorker
+};

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

@@ -0,0 +1,23 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/clients/installer/managed-tool-refresh-session.js
+var refreshesThisSession = 0;
+function reserveManagedToolRefreshSlot(maxPerSession) {
+  if (refreshesThisSession >= maxPerSession)
+    return false;
+  refreshesThisSession += 1;
+  return true;
+}
+function releaseManagedToolRefreshSlot() {
+  if (refreshesThisSession > 0)
+    refreshesThisSession -= 1;
+}
+function resetManagedToolRefreshSession() {
+  refreshesThisSession = 0;
+}
+
+export {
+  reserveManagedToolRefreshSlot,
+  releaseManagedToolRefreshSlot,
+  resetManagedToolRefreshSession
+};

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

@@ -0,0 +1,45 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  DEAD_CODE_DELTA_MAX_SHOWN,
+  PythonDeadCodeClient,
+  deadCodeIssueCount,
+  deadCodeIssueKey,
+  deadCodeIssues,
+  formatDeadCodeDelta,
+  getDeadCodeClients,
+  parseVultureOutput,
+  stableFindingKey
+} from "./chunk-TT22N74J.js";
+import "./chunk-7U2IDNXN.js";
+import "./chunk-TO6WL3GM.js";
+import "./chunk-ZMOL6RQC.js";
+import "./chunk-I7SPGOWI.js";
+import "./chunk-3I5QFT3N.js";
+import "./chunk-PAK6IDME.js";
+import "./chunk-U3VGR4VU.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 {
+  DEAD_CODE_DELTA_MAX_SHOWN,
+  PythonDeadCodeClient,
+  deadCodeIssueCount,
+  deadCodeIssueKey,
+  deadCodeIssues,
+  formatDeadCodeDelta,
+  getDeadCodeClients,
+  parseVultureOutput,
+  stableFindingKey
+};

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

@@ -0,0 +1,188 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  withFactTree
+} from "./chunk-JOLITGCC.js";
+import {
+  childrenOfType,
+  firstChildOfType,
+  walk
+} from "./chunk-LW6XKDZQ.js";
+import {
+  isJstsFactFile
+} from "./chunk-5ZEJHV35.js";
+import {
+  logLatency
+} from "./chunk-5THXD6X5.js";
+
+// dist/clients/dispatch/facts/import-facts.js
+function importFactsApplyTo(filePath) {
+  return isJstsFactFile(filePath);
+}
+function stripQuotes(raw) {
+  return raw.replace(/^["'`]+|["'`]+$/g, "");
+}
+function parseStaticImport(node, moduleType) {
+  const sourceNode = firstChildOfType(node, "string");
+  if (!sourceNode)
+    return null;
+  const source = stripQuotes(sourceNode.text);
+  const clause = firstChildOfType(node, "import_clause");
+  if (!clause) {
+    return { source, names: [], moduleType };
+  }
+  const entry = { source, names: [], moduleType };
+  for (const child of clause.children ?? []) {
+    if (!child)
+      continue;
+    if (child.type === "identifier") {
+      entry.defaultName = child.text;
+    } else if (child.type === "namespace_import") {
+      const id = firstChildOfType(child, "identifier");
+      if (id)
+        entry.namespace = id.text;
+    } else if (child.type === "named_imports") {
+      for (const spec of childrenOfType(child, "import_specifier")) {
+        const ids = childrenOfType(spec, "identifier");
+        const local = ids.length ? ids[ids.length - 1].text : void 0;
+        if (local)
+          entry.names.push(local);
+      }
+    }
+  }
+  return entry;
+}
+function parseReExport(node) {
+  const sourceNode = firstChildOfType(node, "string");
+  if (!sourceNode)
+    return null;
+  const source = stripQuotes(sourceNode.text);
+  const clause = firstChildOfType(node, "export_clause");
+  if (!clause) {
+    return { source, names: [] };
+  }
+  const names = [];
+  for (const spec of childrenOfType(clause, "export_specifier")) {
+    const ids = childrenOfType(spec, "identifier");
+    const name = ids.length ? ids[ids.length - 1].text : void 0;
+    if (name)
+      names.push(name);
+  }
+  return { source, names };
+}
+var importFactProvider = {
+  id: "fact.file.imports",
+  provides: ["file.imports", "file.reexports", "file.importFactsCoverage"],
+  requires: ["file.content"],
+  appliesTo(ctx) {
+    return importFactsApplyTo(ctx.filePath);
+  },
+  async run(ctx, store) {
+    const content = store.getFileFact(ctx.filePath, "file.content");
+    const setEmpty = (complete = false) => {
+      store.setFileFact(ctx.filePath, "file.imports", []);
+      store.setFileFact(ctx.filePath, "file.reexports", []);
+      store.setFileFact(ctx.filePath, "file.importFactsCoverage", complete ? "complete" : "unavailable");
+    };
+    if (content == null) {
+      setEmpty();
+      return;
+    }
+    const parsed = await withFactTree(ctx.filePath, content, (root) => {
+      let hasEsm = false;
+      let hasCjs = false;
+      const importNodes = [];
+      const reExportNodes = [];
+      for (const child of root.children ?? []) {
+        if (!child)
+          continue;
+        if (child.type === "import_statement") {
+          hasEsm = true;
+          importNodes.push(child);
+        } else if (child.type === "export_statement") {
+          const isReExport = Boolean(firstChildOfType(child, "from"));
+          if (isReExport || firstChildOfType(child, "export_clause")) {
+            hasEsm = true;
+          }
+          if (isReExport)
+            reExportNodes.push(child);
+        }
+      }
+      const dynamicRaw = [];
+      walk(root, (node) => {
+        if (node.type === "call_expression") {
+          const callee = node.children?.[0];
+          const args = firstChildOfType(node, "arguments");
+          const strArg = args ? firstChildOfType(args, "string") : void 0;
+          if (!strArg)
+            return;
+          const source = stripQuotes(strArg.text);
+          if (callee?.type === "import") {
+            dynamicRaw.push({ source, kind: "import" });
+          } else if (callee?.type === "identifier" && callee.text === "require") {
+            dynamicRaw.push({ source, kind: "require" });
+            hasCjs = true;
+          }
+        } else if (node.type === "member_expression") {
+          const obj = node.children?.[0];
+          if (obj?.type === "identifier" && obj.text === "module") {
+            const prop = firstChildOfType(node, "property_identifier");
+            if (prop?.text === "exports")
+              hasCjs = true;
+          }
+        }
+      });
+      const moduleType = hasEsm && !hasCjs ? "esm" : hasCjs && !hasEsm ? "cjs" : hasEsm || hasCjs ? "esm" : "unknown";
+      const imports = [];
+      for (const node of importNodes) {
+        const entry = parseStaticImport(node, moduleType);
+        if (entry)
+          imports.push(entry);
+      }
+      let dynamicCount = 0;
+      for (const d of dynamicRaw) {
+        if (d.kind === "import") {
+          imports.push({
+            source: d.source,
+            names: [],
+            isDynamic: true,
+            moduleType
+          });
+        } else {
+          imports.push({ source: d.source, names: [], moduleType: "cjs" });
+        }
+        dynamicCount++;
+      }
+      store.setFileFact(ctx.filePath, "file.imports", imports);
+      const reexports = [];
+      for (const node of reExportNodes) {
+        const r = parseReExport(node);
+        if (r)
+          reexports.push(r);
+      }
+      store.setFileFact(ctx.filePath, "file.reexports", reexports);
+      if (dynamicCount > 0 || reexports.length > 0) {
+        logLatency({
+          type: "call_graph_facts",
+          filePath: ctx.filePath,
+          durationMs: 0,
+          metadata: {
+            moduleType,
+            staticImports: imports.length - dynamicCount,
+            dynamicImports: dynamicCount,
+            reexports: reexports.length,
+            starReexports: reexports.filter((r) => r.names.length === 0).length
+          }
+        });
+      }
+    }, importFactProvider.id);
+    if (!parsed.parsed)
+      setEmpty();
+    else
+      store.setFileFact(ctx.filePath, "file.importFactsCoverage", "complete");
+  }
+};
+
+export {
+  importFactsApplyTo,
+  importFactProvider
+};