@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/chunk-5RXBNSW2.js

@@ -0,0 +1,266 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  getStartupScanMaxSourceFilesDerived
+} from "./chunk-LNAKEO63.js";
+import {
+  shouldRecurseIntoDir,
+  walkTreeStackAsync,
+  walkTreeStackSync
+} from "./chunk-VHQLPIRJ.js";
+import {
+  getProjectIgnoreMatcher
+} from "./chunk-VN2AXLEX.js";
+import {
+  getDirectoryMarkers,
+  registerWorkspaceTopologyReset
+} from "./chunk-VNMT7C64.js";
+import {
+  lazyEnvNumber
+} from "./chunk-UK3CMEAL.js";
+import {
+  BoundedLruCache
+} from "./chunk-ABBOA7UD.js";
+import {
+  isAtOrAboveHomeDir,
+  normalizeMapKey
+} from "./chunk-Q5U6FMDI.js";
+
+// dist/clients/startup-scan.js
+import * as os from "node:os";
+import * as path from "node:path";
+var PROJECT_ROOT_MARKERS = [
+  ".git",
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "composer.json"
+];
+var MAX_STARTUP_SCAN_ENTRIES = 5e4;
+var SOURCE_FILE_PATTERN = /\.(ts|tsx|js|jsx|py|go|rs|rb)$/;
+var DEFAULT_STARTUP_SCAN_VERDICT_TTL_MS = 24 * 60 * 60 * 1e3;
+var _ttl = lazyEnvNumber("PI_LENS_STARTUP_SCAN_VERDICT_TTL_MS", DEFAULT_STARTUP_SCAN_VERDICT_TTL_MS);
+var getStartupScanVerdictTtlMs = _ttl.get;
+var _resetStartupScanVerdictTtlForTests = _ttl._resetForTests;
+var _maxEntries = lazyEnvNumber("PI_LENS_STARTUP_SCAN_MAX_ENTRIES", MAX_STARTUP_SCAN_ENTRIES);
+var getStartupScanMaxEntries = _maxEntries.get;
+var _resetStartupScanMaxEntriesForTests = _maxEntries._resetForTests;
+function isStartupScanVerdictFresh(verdict, now = Date.now()) {
+  if (verdict.reason !== "too-many-source-files" && verdict.reason !== "too-many-entries")
+    return true;
+  if (typeof verdict.computedAt !== "number")
+    return false;
+  return now - verdict.computedAt < getStartupScanVerdictTtlMs();
+}
+function findNearestProjectRoot(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    const entryNames = getDirectoryMarkers(current).entryNames;
+    if (PROJECT_ROOT_MARKERS.some((marker) => entryNames.has(marker))) {
+      return current;
+    }
+    const parent = path.dirname(current);
+    if (parent === current)
+      return null;
+    current = parent;
+  }
+}
+function makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries) {
+  return (entry, fullPath) => {
+    state.visited += 1;
+    if (entry.isDirectory()) {
+      const recurse = shouldRecurseIntoDir(entry, fullPath, {
+        ignoreMatcher,
+        followSymlinks: true
+      });
+      if (state.visited >= maxEntries) {
+        state.entryBudgetExceeded = true;
+        return "stop";
+      }
+      return recurse ? "recurse" : "skip";
+    }
+    if (entry.isFile() && SOURCE_FILE_PATTERN.test(entry.name) && !ignoreMatcher.isIgnored(fullPath, false)) {
+      state.count += 1;
+      if (state.count > limit)
+        return "stop";
+    }
+    if (state.visited >= maxEntries) {
+      state.entryBudgetExceeded = true;
+      return "stop";
+    }
+    return "skip";
+  };
+}
+function walkSourceCount(dir, limit, maxEntries) {
+  const state = {
+    count: 0,
+    visited: 0,
+    entryBudgetExceeded: false
+  };
+  const rootDir = path.resolve(dir);
+  const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
+  walkTreeStackSync(rootDir, makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries));
+  return { count: state.count, entryBudgetExceeded: state.entryBudgetExceeded };
+}
+function countSourceFilesWithinLimit(dir, limit) {
+  return walkSourceCount(dir, limit, Number.POSITIVE_INFINITY).count;
+}
+var startupScanContextCache = new BoundedLruCache(32);
+registerWorkspaceTopologyReset(() => startupScanContextCache.clear());
+function startupScanCacheKey(cwd, options) {
+  return [
+    normalizeMapKey(path.resolve(cwd)),
+    options.homeDir ? normalizeMapKey(path.resolve(options.homeDir)) : "",
+    options.maxSourceFiles ?? "",
+    options.maxScanEntries ?? ""
+  ].join("|");
+}
+var __testing = { startupScanCacheKey };
+function resolveStartupScanContext(cwd, options = {}) {
+  const cacheKey = startupScanCacheKey(cwd, options);
+  const cached = startupScanContextCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const result = {
+    ...computeStartupScanContext(cwd, options),
+    computedAt: Date.now()
+  };
+  startupScanContextCache.set(cacheKey, result);
+  return result;
+}
+function computeStartupScanContext(cwd, options = {}) {
+  const resolvedCwd = path.resolve(cwd);
+  const homeDir = path.resolve(options.homeDir ?? os.homedir());
+  const maxSourceFiles = options.maxSourceFiles ?? getStartupScanMaxSourceFilesDerived(resolvedCwd);
+  const maxScanEntries = options.maxScanEntries ?? getStartupScanMaxEntries();
+  const projectRoot = findNearestProjectRoot(resolvedCwd);
+  if (!projectRoot) {
+    return {
+      cwd: resolvedCwd,
+      scanRoot: resolvedCwd,
+      projectRoot: null,
+      canWarmCaches: false,
+      reason: isAtOrAboveHomeDir(resolvedCwd, homeDir) ? "home-dir" : "no-project-root"
+    };
+  }
+  if (isAtOrAboveHomeDir(projectRoot, homeDir)) {
+    return {
+      cwd: resolvedCwd,
+      scanRoot: projectRoot,
+      projectRoot,
+      canWarmCaches: false,
+      reason: "home-dir"
+    };
+  }
+  const { count: sourceFileCount, entryBudgetExceeded } = walkSourceCount(projectRoot, maxSourceFiles, maxScanEntries);
+  if (sourceFileCount > maxSourceFiles || entryBudgetExceeded) {
+    return {
+      cwd: resolvedCwd,
+      scanRoot: projectRoot,
+      projectRoot,
+      canWarmCaches: false,
+      reason: entryBudgetExceeded ? "too-many-entries" : "too-many-source-files",
+      sourceFileCount
+    };
+  }
+  return {
+    cwd: resolvedCwd,
+    scanRoot: projectRoot,
+    projectRoot,
+    canWarmCaches: true,
+    sourceFileCount
+  };
+}
+async function walkSourceCountAsync(dir, limit, maxEntries, opts = {}) {
+  const state = {
+    count: 0,
+    visited: 0,
+    entryBudgetExceeded: false
+  };
+  const rootDir = path.resolve(dir);
+  const ignoreMatcher = getProjectIgnoreMatcher(rootDir);
+  await walkTreeStackAsync(rootDir, makeSourceCountVisitor(state, ignoreMatcher, limit, maxEntries), {
+    // Yield every 100 entries by default. Empirically each yield costs
+    // ~0.1ms of overhead and a 2k-file project produces ~20 yields, so the
+    // total async overhead is well under 5ms while keeping per-burst sync
+    // work under 50ms (the perceptual threshold for "instant" keystrokes).
+    budgetMs: opts.budgetMs ?? 8,
+    // #703: prime the tracked-files set ONCE before the walk (not per file)
+    // so a tracked file matching a `.gitignore`/global pattern isn't dropped
+    // from the startup source-file count. Fail-open: resolves even when git
+    // is absent, and `isIgnored` degrades to pattern-only if this never
+    // resolves before a caller inspects results.
+    beforeWalk: () => ignoreMatcher.ensureTrackedIndex()
+  });
+  return { count: state.count, entryBudgetExceeded: state.entryBudgetExceeded };
+}
+async function countSourceFilesWithinLimitAsync(dir, limit, opts = {}) {
+  return (await walkSourceCountAsync(dir, limit, Number.POSITIVE_INFINITY, opts)).count;
+}
+async function resolveStartupScanContextAsync(cwd, options = {}) {
+  const cacheKey = startupScanCacheKey(cwd, options);
+  const cached = startupScanContextCache.get(cacheKey);
+  if (cached)
+    return cached;
+  const resolvedCwd = path.resolve(cwd);
+  const homeDir = path.resolve(options.homeDir ?? os.homedir());
+  const maxSourceFiles = options.maxSourceFiles ?? getStartupScanMaxSourceFilesDerived(resolvedCwd);
+  const maxScanEntries = options.maxScanEntries ?? getStartupScanMaxEntries();
+  const projectRoot = findNearestProjectRoot(resolvedCwd);
+  let result;
+  if (!projectRoot) {
+    result = {
+      cwd: resolvedCwd,
+      scanRoot: resolvedCwd,
+      projectRoot: null,
+      canWarmCaches: false,
+      reason: isAtOrAboveHomeDir(resolvedCwd, homeDir) ? "home-dir" : "no-project-root"
+    };
+  } else if (isAtOrAboveHomeDir(projectRoot, homeDir)) {
+    result = {
+      cwd: resolvedCwd,
+      scanRoot: projectRoot,
+      projectRoot,
+      canWarmCaches: false,
+      reason: "home-dir"
+    };
+  } else {
+    const { count: sourceFileCount, entryBudgetExceeded } = await walkSourceCountAsync(projectRoot, maxSourceFiles, maxScanEntries);
+    if (sourceFileCount > maxSourceFiles || entryBudgetExceeded) {
+      result = {
+        cwd: resolvedCwd,
+        scanRoot: projectRoot,
+        projectRoot,
+        canWarmCaches: false,
+        reason: entryBudgetExceeded ? "too-many-entries" : "too-many-source-files",
+        sourceFileCount
+      };
+    } else {
+      result = {
+        cwd: resolvedCwd,
+        scanRoot: projectRoot,
+        projectRoot,
+        canWarmCaches: true,
+        sourceFileCount
+      };
+    }
+  }
+  result = { ...result, computedAt: Date.now() };
+  startupScanContextCache.set(cacheKey, result);
+  return result;
+}
+
+export {
+  MAX_STARTUP_SCAN_ENTRIES,
+  getStartupScanVerdictTtlMs,
+  _resetStartupScanVerdictTtlForTests,
+  getStartupScanMaxEntries,
+  _resetStartupScanMaxEntriesForTests,
+  isStartupScanVerdictFresh,
+  findNearestProjectRoot,
+  countSourceFilesWithinLimit,
+  __testing,
+  resolveStartupScanContext,
+  countSourceFilesWithinLimitAsync,
+  resolveStartupScanContextAsync
+};

package/node_modules/pi-lens/dist/chunk-5THXD6X5.js

@@ -0,0 +1,201 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  createNdjsonLogger,
+  getGlobalPiLensLogDir,
+  getMaxLogSizeMB,
+  getTurnId,
+  isTestMode
+} from "./chunk-UK3CMEAL.js";
+import {
+  normalizeLoggedPath
+} from "./chunk-Q5U6FMDI.js";
+
+// dist/clients/latency-logger.js
+import * as path from "node:path";
+var LATENCY_LOG_DIR = getGlobalPiLensLogDir();
+var LATENCY_LOG_FILE = path.join(LATENCY_LOG_DIR, "latency.log");
+var writer = createNdjsonLogger({
+  filePath: LATENCY_LOG_FILE,
+  maxBytes: getMaxLogSizeMB() * 1024 * 1024
+});
+var RECENT_PHASE_CAP = 5;
+var recentPhases = [];
+var LAST_PHASE_EXCLUDED = /* @__PURE__ */ new Set([
+  "loop_block",
+  "lsp_typescript_project_identity",
+  "advisory_provenance_decision",
+  "authoritative_content_attachment_decision",
+  "agent_end_deferred_mutation_drain",
+  "agent_end_deferred_mutation_requeue",
+  "session_end_bus_rollup",
+  "cache_usage_summary",
+  "test_runner_failed_target_state",
+  "turn_end_test_selection",
+  "lsp_aux_wait_outcome",
+  "tool_set_mutation",
+  "availability_decision",
+  "finding_dead_path_drop",
+  "finding_stale_line_demote",
+  "finding_path_stat_budget_exhausted",
+  "lsp_scanner_coverage_gap",
+  "lsp_notify_resync_deferred",
+  "lsp_notify_write_late_landed",
+  "lsp_notify_stall_cpu_busy",
+  "degradation_ledger",
+  "path_attribution_verified_rollup",
+  "concurrent_session_bind_rollup",
+  "auxiliary_readiness",
+  "lsp_empty_first_publish_held",
+  "lsp_diagnostics_fence",
+  "lsp_rules_refreshed",
+  "read_guard_conversation_read",
+  "read_widening_note",
+  "session_handoff_slot",
+  "session_handoff_adopt",
+  "session_store_action",
+  "session_end_fence_rollup",
+  "format_late_resync_chained"
+]);
+var liveBrackets = /* @__PURE__ */ new Map();
+var closedBrackets = [];
+function phaseStarted(phase) {
+  const token = { phase, startedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  liveBrackets.set(token, true);
+  return token;
+}
+function phaseFinished(token) {
+  if (!liveBrackets.delete(token))
+    return;
+  closedBrackets = [
+    {
+      phase: token.phase,
+      startedAt: token.startedAt,
+      closedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    ...closedBrackets
+  ].slice(0, RECENT_PHASE_CAP);
+}
+var oncePerSessionPhases = /* @__PURE__ */ new Set();
+var sessionRecordSeq = 0;
+function mintSessionRecordId() {
+  sessionRecordSeq += 1;
+  return `${process.pid.toString(36)}-${Date.now().toString(36)}-${sessionRecordSeq.toString(36)}`;
+}
+var sessionRecordId = mintSessionRecordId();
+function currentSessionRecordId() {
+  return sessionRecordId;
+}
+function claimKey(phase, scope) {
+  return `${phase}\0${scope}`;
+}
+function claimPhaseOncePerSession(phase, scope) {
+  const key = claimKey(phase, scope);
+  if (oncePerSessionPhases.has(key))
+    return false;
+  oncePerSessionPhases.add(key);
+  return true;
+}
+function releasePhaseClaim(phase, scope) {
+  oncePerSessionPhases.delete(claimKey(phase, scope));
+}
+function logLatency(entry) {
+  const ts = (/* @__PURE__ */ new Date()).toISOString();
+  if (entry.type === "phase" && entry.phase && !LAST_PHASE_EXCLUDED.has(entry.phase)) {
+    recentPhases = [
+      { phase: entry.phase, ts, metadata: entry.metadata },
+      ...recentPhases
+    ].slice(0, RECENT_PHASE_CAP);
+  }
+  if (isTestMode()) {
+    return;
+  }
+  writer.log({
+    ...entry,
+    ts,
+    pid: process.pid,
+    turnId: entry.turnId ?? getTurnId(),
+    filePath: normalizeLoggedPath(entry.filePath)
+  });
+}
+
+// dist/clients/config-diagnostic-codes.js
+var STABILITY_TIER_KEY = "x-stability";
+var CONFIG_SCHEMA_ID = "https://raw.githubusercontent.com/apmantza/pi-lens/master/docs/schema/pi-lens-config-v1.json";
+var CONFIG_SCHEMA_ANCHOR_KEY = "$schema";
+function configDiagnosticMarker(code) {
+  return `[${code}]`;
+}
+function withConfigDiagnosticCode(message, code) {
+  const marker = configDiagnosticMarker(code);
+  return message.includes(marker) ? message : `${message} ${marker}`;
+}
+var LSP_DEPRECATION_WINDOW = {
+  deprecatedSince: "4.1.4",
+  removeNotBefore: "5.0.0"
+};
+var LEGACY_KEY = {
+  kind: "key",
+  code: "PILENS_CFG_0002",
+  ...LSP_DEPRECATION_WINDOW
+};
+var LEGACY_FILE = {
+  kind: "file",
+  code: "PILENS_CFG_0003",
+  ...LSP_DEPRECATION_WINDOW
+};
+var DEPRECATED_CONFIG_SURFACES = [
+  {
+    ...LEGACY_KEY,
+    surface: "servers",
+    reason: "custom-server definitions move to the unified catalog schema; the bare string command + args form is replaced by the trust-gated ProcessSpec (#2416)."
+  },
+  {
+    ...LEGACY_KEY,
+    surface: "serverOverrides",
+    reason: "per-server initializationOptions overrides fold into the catalog's field-wise merge, keyed by the same public server IDs (#2416)."
+  },
+  {
+    ...LEGACY_KEY,
+    surface: "disabledServers",
+    reason: "replaced by the catalog's per-entry `enabled: false`, which carries monotonic deny precedence (#1416/#2415)."
+  },
+  {
+    ...LEGACY_KEY,
+    surface: "warmFiles",
+    reason: "session warm-up seeds become a per-server catalog field rather than a config-root list (#2416)."
+  },
+  {
+    ...LEGACY_FILE,
+    surface: ".pi-lens/lsp.json",
+    reason: "project LSP settings consolidate into `.pi-lens.json` under the unified envelope (#2426)."
+  },
+  {
+    ...LEGACY_FILE,
+    surface: "pi-lsp.json",
+    reason: "pre-rename project location; superseded by `.pi-lens.json` (#2426)."
+  },
+  {
+    ...LEGACY_FILE,
+    surface: "pi-lens.json",
+    reason: "undotted project-config basename; superseded by `.pi-lens.json` (#2426)."
+  },
+  {
+    ...LEGACY_FILE,
+    surface: "~/.pi-lens/lsp.json",
+    reason: "global LSP settings consolidate into `~/.pi-lens/config.json` (#2426)."
+  }
+];
+
+export {
+  STABILITY_TIER_KEY,
+  CONFIG_SCHEMA_ID,
+  CONFIG_SCHEMA_ANCHOR_KEY,
+  withConfigDiagnosticCode,
+  DEPRECATED_CONFIG_SURFACES,
+  phaseStarted,
+  phaseFinished,
+  currentSessionRecordId,
+  claimPhaseOncePerSession,
+  releasePhaseClaim,
+  logLatency
+};

package/node_modules/pi-lens/dist/chunk-5W3R6LFT.js

@@ -0,0 +1,24 @@
+import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+
+// dist/clients/symbol-containment.js
+function findOwnerName(candidates, targetStart, targetEnd) {
+  let best;
+  for (const candidate of candidates) {
+    const span = candidate.endLine - candidate.startLine;
+    const targetSpan = targetEnd - targetStart;
+    const contains = candidate.startLine <= targetStart && candidate.endLine >= targetEnd && span > targetSpan;
+    if (!contains)
+      continue;
+    if (!best || span < best.endLine - best.startLine)
+      best = candidate;
+  }
+  return best?.name;
+}
+function buildQualifiedName(ownerName, symbolName) {
+  return ownerName ? `${ownerName}.${symbolName}` : void 0;
+}
+
+export {
+  findOwnerName,
+  buildQualifiedName
+};