@herbertgao/pi-extensions 2026.10.1 → 2026.10.3

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

@@ -0,0 +1,37 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  GitleaksClient,
+  PLACEHOLDER_SECRET_REGEXES,
+  classifyAndFilterFindings,
+  hasGitRepo,
+  hasGitleaksSignal,
+  parseGitleaksReport,
+  writeScopedGitleaksConfig
+} from "./chunk-DMS52BEP.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 {
+  GitleaksClient,
+  PLACEHOLDER_SECRET_REGEXES,
+  classifyAndFilterFindings,
+  hasGitRepo,
+  hasGitleaksSignal,
+  parseGitleaksReport,
+  writeScopedGitleaksConfig
+};

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

@@ -0,0 +1,78 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  loadPiLensProjectConfig
+} from "./chunk-N2IRDBZI.js";
+import {
+  lazyEnvNumber,
+  toPositiveFinite
+} from "./chunk-VSMJK3ZJ.js";
+
+// dist/clients/project-scale.js
+var DEFAULT_PROJECT_SCALE_BASE = 2e3;
+var _envBase = lazyEnvNumber("PI_LENS_MAX_PROJECT_FILES", DEFAULT_PROJECT_SCALE_BASE);
+function getProjectScaleBase(cwd) {
+  if (cwd) {
+    const config = loadPiLensProjectConfig(cwd);
+    const configBase = toPositiveFinite(config.maxProjectFiles);
+    if (configBase > 0)
+      return Math.floor(configBase);
+  }
+  return _envBase.get();
+}
+var PROJECT_SCALE_RATIOS = {
+  /** project-diagnostics scanner: files kept. 0.25 * 2,000 = 500. */
+  projectDiagnosticsScanner: 0.25,
+  /** review graph: files kept. 0.5 * 2,000 = 1,000. */
+  reviewGraph: 0.5,
+  /** startup scan: source files counted. 1.25 * 2,000 = 2,500. */
+  startupScan: 1.25,
+  /** jscpd: directory entries visited (its own gate, not source-filter's). 3 * 2,000 = 6,000. */
+  jscpd: 3,
+  /** word index: files indexed. 3 * 2,000 = 6,000. */
+  wordIndex: 3
+};
+function deriveBudget(ratio, cwd) {
+  return Math.max(1, Math.round(getProjectScaleBase(cwd) * ratio));
+}
+function getProjectDiagnosticsScannerMaxFiles(cwd) {
+  return deriveBudget(PROJECT_SCALE_RATIOS.projectDiagnosticsScanner, cwd);
+}
+var REVIEW_GRAPH_LINEAR_CEILING_BASE = 4e3;
+var REVIEW_GRAPH_TAPER_SCALE = 8e3;
+var REVIEW_GRAPH_HARD_CEILING = 5e3;
+function taperedReviewGraphMaxFiles(base) {
+  const linearValue = base * PROJECT_SCALE_RATIOS.reviewGraph;
+  if (base <= REVIEW_GRAPH_LINEAR_CEILING_BASE) {
+    return Math.max(1, Math.round(linearValue));
+  }
+  const boundaryValue = REVIEW_GRAPH_LINEAR_CEILING_BASE * PROJECT_SCALE_RATIOS.reviewGraph;
+  const excess = base - REVIEW_GRAPH_LINEAR_CEILING_BASE;
+  const taperedExtra = (REVIEW_GRAPH_HARD_CEILING - boundaryValue) * (excess / (excess + REVIEW_GRAPH_TAPER_SCALE));
+  return Math.max(1, Math.round(boundaryValue + taperedExtra));
+}
+function getReviewGraphMaxFilesDerived(cwd) {
+  if (cwd) {
+    const config = loadPiLensProjectConfig(cwd);
+    const configOverride = config.reviewGraph?.maxFiles;
+    if (configOverride !== void 0)
+      return configOverride;
+  }
+  return taperedReviewGraphMaxFiles(getProjectScaleBase(cwd));
+}
+function getStartupScanMaxSourceFilesDerived(cwd) {
+  return deriveBudget(PROJECT_SCALE_RATIOS.startupScan, cwd);
+}
+function getJscpdMaxEntriesDerived(cwd) {
+  return deriveBudget(PROJECT_SCALE_RATIOS.jscpd, cwd);
+}
+function getWordIndexMaxFilesDerived(cwd) {
+  return deriveBudget(PROJECT_SCALE_RATIOS.wordIndex, cwd);
+}
+
+export {
+  getProjectDiagnosticsScannerMaxFiles,
+  getReviewGraphMaxFilesDerived,
+  getStartupScanMaxSourceFilesDerived,
+  getJscpdMaxEntriesDerived,
+  getWordIndexMaxFilesDerived
+};

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

@@ -0,0 +1,262 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  rootMarkersForFile
+} from "./chunk-VYKKMYVT.js";
+import {
+  createGenerationMap,
+  createGenerationSource
+} from "./chunk-T54VJRAD.js";
+import {
+  getDegradationLedgerGeneration,
+  recordDegradationOnce
+} from "./chunk-7ELY2CSM.js";
+import {
+  logExtension
+} from "./chunk-34OCDWOS.js";
+import {
+  isAtOrAboveHomeDir,
+  isRealGitMarker,
+  isUnderDir,
+  isWindowsPath,
+  nameMatchesMarkerGlob,
+  normalizeEphemeralMapKey
+} from "./chunk-G3RLJYA2.js";
+
+// dist/clients/tool-cwd.js
+import * as os from "node:os";
+import { existsSync, readdirSync } from "node:fs";
+import * as path from "node:path";
+var FORMATTER_MARKERS = {
+  biome: ["biome.json", "biome.jsonc", "package.json", ".gitignore"],
+  prettier: [
+    ".prettierrc",
+    ".prettierrc.json",
+    ".prettierrc.yaml",
+    ".prettierrc.yml",
+    ".prettierrc.js",
+    ".prettierrc.cjs",
+    ".prettierrc.mjs",
+    "prettier.config.js",
+    "prettier.config.cjs",
+    "prettier.config.mjs",
+    ".prettierignore",
+    "package.json",
+    ".gitignore"
+  ],
+  ruff: ["pyproject.toml", "ruff.toml", ".ruff.toml", ".gitignore"],
+  black: ["pyproject.toml", "black.toml", ".black", ".gitignore"],
+  "php-cs-fixer": [".php-cs-fixer.php", ".php-cs-fixer.dist.php", ".gitignore"],
+  sqlfluff: [".sqlfluff", "pyproject.toml", "setup.cfg", ".gitignore"],
+  oxfmt: [
+    "oxfmt.toml",
+    ".oxfmtrc.json",
+    "vite-plus.json",
+    "package.json",
+    ".gitignore"
+  ],
+  rustfmt: ["rustfmt.toml", ".rustfmt.toml", "Cargo.toml", ".gitignore"],
+  rubocop: [".rubocop.yml", ".rubocop.yaml", ".gitignore"],
+  standardrb: [".standard.yml", ".standard.yaml", ".gitignore"],
+  "clang-format": [".clang-format", "_clang-format", ".gitignore"],
+  stylua: ["stylua.toml", ".stylua.toml", ".gitignore"],
+  ocamlformat: [".ocamlformat", ".gitignore"],
+  "google-java-format": [".google-java-format", ".editorconfig", ".gitignore"],
+  cljfmt: [".cljfmt.edn", "cljfmt.edn", ".cljfmt", ".gitignore"],
+  "cmake-format": [
+    ".cmake-format",
+    ".cmake-format.yaml",
+    ".cmake-format.yml",
+    ".cmake-format.json",
+    ".cmake-format.py",
+    "cmake-format.yaml",
+    "cmake-format.yml",
+    ".editorconfig",
+    ".gitignore"
+  ],
+  "psscriptanalyzer-format": [
+    "PSScriptAnalyzerSettings.psd1",
+    "ScriptAnalyzerSettings.psd1",
+    ".gitignore"
+  ],
+  csharpier: [
+    ".csharpierrc",
+    ".csharpierrc.json",
+    ".csharpierrc.yaml",
+    ".csharpierrc.yml",
+    ".gitignore"
+  ],
+  ormolu: [".ormolu", ".gitignore"],
+  taplo: ["taplo.toml", ".taplo.toml", ".gitignore"],
+  terraform: [".terraform.lock.hcl", ".gitignore"],
+  swiftformat: [".swiftformat", ".gitignore"],
+  fantomas: [".fantomasignore", ".editorconfig", ".gitignore"],
+  mix: [".formatter.exs", ".gitignore"],
+  shfmt: [".editorconfig", ".gitignore"],
+  ktlint: [".editorconfig", ".gitignore"],
+  ktfmt: [
+    ".editorconfig",
+    ".ktfmt",
+    ".ktfmt.kts",
+    "build.gradle",
+    "build.gradle.kts",
+    "settings.gradle",
+    "settings.gradle.kts",
+    ".gitignore"
+  ],
+  typstyle: [".gitignore"]
+};
+var toolCwdGeneration = createGenerationSource("tool-cwd");
+var logged = createGenerationMap("tool-cwd-resolution-log");
+function _toolCwdEphemeralKey(parts) {
+  return parts.map(normalizeEphemeralMapKey).join("\0");
+}
+function syncGeneration() {
+  if (toolCwdGeneration.current() === getDegradationLedgerGeneration())
+    return;
+  logged.clear();
+  while (toolCwdGeneration.current() < getDegradationLedgerGeneration()) {
+    toolCwdGeneration.bump();
+  }
+}
+function walkMarkerRoot(startDir, markers, homeDir) {
+  let current = path.resolve(startDir);
+  for (let depth = 0; depth < 64; depth++) {
+    if (isAtOrAboveHomeDir(current, homeDir))
+      break;
+    for (const marker of markers) {
+      const slash = marker.replace(/\\/g, "/").lastIndexOf("/");
+      const parent = slash >= 0 ? marker.slice(0, slash) : "";
+      const basename = slash >= 0 ? marker.slice(slash + 1) : marker;
+      const target = parent ? path.join(current, ...parent.split("/").filter(Boolean)) : current;
+      let found = false;
+      if (basename.includes("*")) {
+        try {
+          found = readdirSync(target, { withFileTypes: true }).some((entry) => (entry.isFile() || entry.isSymbolicLink()) && nameMatchesMarkerGlob(entry.name, basename));
+        } catch {
+          found = false;
+        }
+      } else {
+        found = existsSync(path.join(target, basename));
+      }
+      if (found)
+        return { root: current, marker };
+    }
+    const parentDir = path.dirname(current);
+    if (parentDir === current)
+      break;
+    current = parentDir;
+  }
+  return { root: null };
+}
+function findMarkerRoot(startDir, markers, homeDir) {
+  syncGeneration();
+  return walkMarkerRoot(startDir, markers, homeDir);
+}
+function markersFor(kind, tool, file, ctx) {
+  if (kind === "lsp")
+    return ctx.rootMarkers ?? [];
+  if (kind === "runner")
+    return ctx.rootMarkers ?? rootMarkersForFile(file, tool);
+  return FORMATTER_MARKERS[tool] ?? [".gitignore"];
+}
+function emitResolution(kind, tool, cwd, reason) {
+  syncGeneration();
+  const key = _toolCwdEphemeralKey([kind, tool, cwd, reason]);
+  if (logged.current(key) !== 0)
+    return;
+  logged.bump(key);
+  logExtension({
+    subsystem: "tool-cwd",
+    level: "debug",
+    message: `cwd ${kind} ${tool} cwd=${cwd} reason=${reason}`
+  });
+}
+function logRunnerAdvisoryOnce(ctx, tool, root, message) {
+  syncGeneration();
+  const key = _toolCwdEphemeralKey(["runner-advisory", tool, root]);
+  if (logged.current(key) !== 0)
+    return;
+  logged.bump(key);
+  ctx.log(message, "debug");
+}
+function resolveToolCwd(kind, tool, file, ctx) {
+  const dispatchRoot = path.resolve(ctx.cwd ?? process.cwd());
+  const absoluteFile = path.resolve(file);
+  const fileDir = path.dirname(absoluteFile);
+  const homeDir = ctx.homeDir ?? os.homedir();
+  const insideDispatch = isUnderDir(absoluteFile, dispatchRoot);
+  if (ctx.serverRoot) {
+    const rootPath = isWindowsPath(ctx.serverRoot) ? path.win32 : path;
+    const serverRoot = rootPath.resolve(ctx.serverRoot);
+    if (!ctx.suppressTelemetry)
+      emitResolution(kind, tool, serverRoot, "server-root");
+    return { cwd: serverRoot };
+  }
+  const markers = markersFor(kind, tool, absoluteFile, ctx);
+  const markerResult = markers.length ? findMarkerRoot(fileDir, markers, ctx.allowHomeMarker ? path.parse(homeDir).root : homeDir) : { root: null };
+  const markerRoot = markerResult.root;
+  if (markerRoot && (insideDispatch ? isUnderDir(markerRoot, dispatchRoot) : true)) {
+    const finalReason = `marker:${markerResult.marker ?? markers[0]}`;
+    if (!ctx.suppressTelemetry)
+      emitResolution(kind, tool, markerRoot, finalReason);
+    return {
+      cwd: markerRoot,
+      ...markerResult.marker !== void 0 ? { marker: markerResult.marker } : {}
+    };
+  }
+  const memo = ctx.toolCwdMemo;
+  if (memo && memo.gitRoot === void 0) {
+    const gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
+    memo.gitRoot = gitResult.root && isRealGitMarker(path.join(gitResult.root, ".git")) ? gitResult.root : null;
+  }
+  const gitRoot = memo && memo.gitRoot !== void 0 ? memo.gitRoot : (() => {
+    const gitResult = findMarkerRoot(fileDir, [".git"], homeDir);
+    return gitResult.root && isRealGitMarker(path.join(gitResult.root, ".git")) ? gitResult.root : null;
+  })();
+  if (gitRoot && (insideDispatch ? isUnderDir(gitRoot, dispatchRoot) : true)) {
+    if (!ctx.suppressTelemetry)
+      emitResolution(kind, tool, gitRoot, "git-root");
+    return { cwd: gitRoot, marker: ".git" };
+  }
+  if (insideDispatch) {
+    if (kind === "formatter") {
+      if (!ctx.suppressTelemetry)
+        emitResolution(kind, tool, fileDir, "file-dir-fallback");
+      if (!ctx.suppressTelemetry && !isUnderDir(fileDir, homeDir)) {
+        recordDegradationOnce({
+          kind: "tool-cwd-resolution",
+          subject: tool,
+          reason: `${kind}:home-cap:${absoluteFile}`
+        });
+      }
+      return { cwd: fileDir };
+    }
+    if (!ctx.suppressTelemetry)
+      emitResolution(kind, tool, dispatchRoot, "dispatch-root");
+    return { cwd: dispatchRoot };
+  }
+  const reason = isUnderDir(fileDir, homeDir) ? "file-dir-fallback" : "home-cap";
+  const fallback = isUnderDir(fileDir, homeDir) ? fileDir : homeDir;
+  if (!ctx.suppressTelemetry)
+    recordDegradationOnce({
+      kind: "tool-cwd-resolution",
+      subject: tool,
+      reason: `${kind}:${reason}:${absoluteFile}`
+    });
+  if (!ctx.suppressTelemetry)
+    emitResolution(kind, tool, fallback, reason);
+  return { cwd: fallback };
+}
+function resolveRunnerCwd(ctx, tool) {
+  return resolveToolCwd("runner", tool, ctx.filePath, ctx).cwd;
+}
+function resolveRunnerCwdWithReason(ctx, tool) {
+  return resolveToolCwd("runner", tool, ctx.filePath, ctx);
+}
+
+export {
+  logRunnerAdvisoryOnce,
+  resolveToolCwd,
+  resolveRunnerCwd,
+  resolveRunnerCwdWithReason
+};

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

@@ -0,0 +1,98 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  canonicalDirectory,
+  listNestedLinkedWorktreeRoots
+} from "./chunk-IMSQR4WO.js";
+import {
+  EXCLUDED_DIRS,
+  getExcludedDirGlobs
+} from "./chunk-T54VJRAD.js";
+import {
+  escapeRegExp
+} from "./chunk-7ELY2CSM.js";
+
+// dist/clients/scratch-tree-policy.js
+import { relative } from "node:path";
+function nestedWorktreeOffsets(cwd) {
+  const base = canonicalDirectory(cwd);
+  return listNestedLinkedWorktreeRoots(cwd).map((root) => relative(base, root));
+}
+function literalExcludedDirNames() {
+  return EXCLUDED_DIRS.filter((name) => !name.includes("*") && !name.includes("?"));
+}
+function getScratchTreeGlobPatterns() {
+  return getExcludedDirGlobs();
+}
+function getScratchTreeDirNames() {
+  return literalExcludedDirNames();
+}
+function getScratchTreeFnmatchPatterns() {
+  return literalExcludedDirNames().map((name) => `*/${name}/*`);
+}
+var SECRETS_LANE_SCRATCH_DIR_NAMES = [
+  // pi-ecosystem / coding-agent data + cache directories.
+  ".pi",
+  // The same agent's rebranded config dir (#3112) — pi's config-dir name is
+  // `pkg.piConfig?.configDir || ".pi"`, so `.omp/agent/sessions` is the very
+  // history `.pi/agent/sessions` holds. Without it the secrets lane READS a
+  // project-local session history and can report a key a user pasted into a
+  // transcript as a blocking first-party leak.
+  ".omp",
+  ".pi-lens",
+  ".claude",
+  ".codex",
+  ".agents",
+  ".worktrees",
+  ".rescue",
+  ".gstack",
+  ".superpowers",
+  ".guardrails",
+  ".playwright-cli",
+  ".playwright-mcp",
+  // git's own internal object storage — binary/compressed, not readable
+  // source; a byte-regex scan of it produces garbage, not real findings.
+  ".git",
+  // Vendored/installed npm packages — third-party noise, not a first-party
+  // leak surface (unlike `vendor`/`third_party`, which are vendored SOURCE
+  // a project can carry an upstream leak in and stays in scope).
+  "node_modules",
+  // Generic build/package-manager CACHES — regenerated from source on every
+  // build/install, never a place a human commits a credential on purpose.
+  // Deliberately excludes build OUTPUT (`dist`/`build`/`out`/`target`/
+  // `coverage`) — a bundler/compiler CAN bake a real secret into output.
+  ".turbo",
+  ".cache",
+  ".parcel-cache",
+  ".svelte-kit",
+  ".nuxt",
+  ".yarn",
+  ".pnpm-store",
+  ".gradle",
+  ".next",
+  ".ruff_cache",
+  ".tox",
+  ".pytest_cache",
+  "venv",
+  ".venv",
+  "__pycache__"
+];
+function getSecretsLaneAllowlistPaths() {
+  return SECRETS_LANE_SCRATCH_DIR_NAMES.map((name) => {
+    const escaped = escapeRegExp(name);
+    return `(?:^|[/\\\\])${escaped}(?:[/\\\\].*)?$`;
+  });
+}
+function isUnderSecretsLaneScratchTree(relPath) {
+  const names = new Set(SECRETS_LANE_SCRATCH_DIR_NAMES.map((n) => n.toLowerCase()));
+  const segments = relPath.split(/[/\\]/).filter(Boolean);
+  return segments.some((segment) => names.has(segment.toLowerCase()));
+}
+
+export {
+  nestedWorktreeOffsets,
+  getScratchTreeGlobPatterns,
+  getScratchTreeDirNames,
+  getScratchTreeFnmatchPatterns,
+  getSecretsLaneAllowlistPaths,
+  isUnderSecretsLaneScratchTree
+};