pi-lens 4.4.2 → 4.4.3

package/dist/{chunk-ESBQHFMJ.js → chunk-EU63SDCG.js}

@@ -1,13 +1,17 @@
 import { createRequire as __pilensCreateRequire } from "node:module"; const require = __pilensCreateRequire(import.meta.url);
+import {
+  resolveOpengrepConfig
+} from "./chunk-VWCXW2E7.js";
 import {
   augmentPythonEnvironment,
   detectPythonEnvironment,
   detectPythonVenv,
   pythonEnvironmentToolCandidates
-} from "./chunk-34WSVGEM.js";
+} from "./chunk-FCSOVF55.js";
 import {
-  resolveOpengrepConfig
-} from "./chunk-VWCXW2E7.js";
+  resolveGitCheckout,
+  resolveLinkedWorktreeOwner
+} from "./chunk-PNQDPDRC.js";
 import {
   extensionsForLanguage,
   getUserRuleRoot,
@@ -36,7 +40,7 @@ import {
   isZizmorAuditTarget,
   logSessionStart,
   resolveZizmorGitHubToken
-} from "./chunk-66VMUL7Q.js";
+} from "./chunk-ACXEQZOU.js";
 import {
   resolveToolCwd
 } from "./chunk-Q7DUK4LX.js";
@@ -63,6 +67,7 @@ import {
   holdOwnChildPid,
   isCommandAvailableAsync,
   isPathIgnoredByProject,
+  isPiLensInternalPath,
   ownerTagForChildren,
   resolveWindowsCommandForEnvironment,
   safeSpawnAsync
@@ -128,6 +133,7 @@ import {
   isAtOrAboveHomeDir,
   isFullyQualified,
   isUnderDir,
+  isVendorPath,
   isWindowsPath,
   matchesWorkspaceMemberPattern,
   normalizeEphemeralMapKey,
@@ -140,16 +146,115 @@ import {
   __require
 } from "./chunk-NXL4FFQQ.js";
 
+// dist/clients/analysis-root.js
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as nodePath from "node:path";
+var PROJECT_MARKERS = [
+  ".git",
+  "package.json",
+  "pyproject.toml",
+  "Cargo.toml",
+  "go.mod",
+  "pom.xml",
+  "build.gradle",
+  "Gemfile",
+  "mix.exs",
+  "composer.json"
+];
+function hasProjectMarker(dir) {
+  return PROJECT_MARKERS.some((marker) => {
+    try {
+      const stat2 = fs.statSync(nodePath.join(dir, marker));
+      return stat2.isFile() || marker === ".git";
+    } catch {
+      return false;
+    }
+  });
+}
+function nearestProjectRoot(filePath) {
+  let dir = nodePath.dirname(nodePath.resolve(filePath));
+  const filesystemRoot = nodePath.parse(dir).root;
+  while (dir !== filesystemRoot) {
+    if (hasProjectMarker(dir))
+      return dir;
+    dir = nodePath.dirname(dir);
+  }
+  return hasProjectMarker(filesystemRoot) ? filesystemRoot : void 0;
+}
+function realPathOrResolved(filePath) {
+  const resolved = nodePath.resolve(filePath);
+  let current = resolved;
+  const missing = [];
+  while (true) {
+    try {
+      const real = fs.realpathSync.native(current);
+      return nodePath.join(real, ...missing.reverse());
+    } catch {
+      const parent = nodePath.dirname(current);
+      if (parent === current)
+        return resolved;
+      missing.push(nodePath.basename(current));
+      current = parent;
+    }
+  }
+}
+function resolveAnalysisRootPath(filePath, sessionRoot, homeDirOverride) {
+  const resolved = realPathOrResolved(filePath);
+  const session = realPathOrResolved(sessionRoot);
+  const tmp = realPathOrResolved(os.tmpdir());
+  const data = process.env.PI_LENS_HOME ? realPathOrResolved(process.env.PI_LENS_HOME) : void 0;
+  if (isVendorPath(resolved))
+    return void 0;
+  if (resolved === tmp || resolved === session || isUnderDir(session, resolved) || !isUnderDir(resolved, session) && (isPiLensInternalPath(resolved, session) || data !== void 0 && (resolved === data || isUnderDir(resolved, data))))
+    return void 0;
+  if (isUnderDir(resolved, session))
+    return session;
+  const checkout = resolveGitCheckout(session);
+  const linked = checkout && resolveLinkedWorktreeOwner(checkout, resolved);
+  if (linked && !isVendorPath(resolved))
+    return linked.root;
+  const candidate = nearestProjectRoot(resolved);
+  if (!candidate || candidate === nodePath.parse(candidate).root)
+    return void 0;
+  const home = realPathOrResolved(homeDirOverride ?? os.homedir());
+  if (isAtOrAboveHomeDir(candidate, home))
+    return void 0;
+  if (candidate === tmp || isUnderDir(session, candidate))
+    return void 0;
+  if (isVendorPath(candidate))
+    return void 0;
+  return candidate;
+}
+function resolveAnalysisRoot(filePath, sessionRoot, homeDirOverride) {
+  const resolved = realPathOrResolved(filePath);
+  if (isVendorPath(resolved))
+    return "none";
+  const checkout = resolveGitCheckout(sessionRoot);
+  if (checkout && resolveLinkedWorktreeOwner(checkout, resolved)) {
+    return "linked-worktree";
+  }
+  const root = resolveAnalysisRootPath(filePath, sessionRoot, homeDirOverride);
+  if (!root)
+    return "none";
+  if (root === nodePath.resolve(sessionRoot))
+    return "session";
+  return "adopted";
+}
+function canWriteAnalysisRoot(mode) {
+  return mode === "session" || mode === "linked-worktree";
+}
+
 // dist/clients/lsp/server.js
-import { existsSync as existsSync3, mkdirSync as mkdirSync2, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, statSync as statSync4 } from "node:fs";
 import { access, readFile, readdir, stat } from "node:fs/promises";
-import os6 from "node:os";
+import os7 from "node:os";
 import path6 from "node:path";
 
 // dist/clients/sgconfig.js
 import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
+import * as fs2 from "node:fs";
+import * as os2 from "node:os";
 import * as path from "node:path";
 var SGCONFIG_NAMES = ["sgconfig.yml", "sgconfig.yaml"];
 function findLocalSgconfig(startDir) {
@@ -157,7 +262,7 @@ function findLocalSgconfig(startDir) {
 }
 function canonicalDir(dir) {
   try {
-    return fs.realpathSync.native(dir);
+    return fs2.realpathSync.native(dir);
   } catch {
     return path.resolve(dir);
   }
@@ -200,7 +305,7 @@ function getAstGrepRuleSources(projectRoot = process.cwd()) {
   });
   const seen = /* @__PURE__ */ new Set();
   return candidates.filter((source) => {
-    if (!fs.existsSync(source.dir))
+    if (!fs2.existsSync(source.dir))
       return false;
     const key = canonicalDir(source.dir);
     if (seen.has(key))
@@ -213,7 +318,7 @@ function findYamlFiles(dir) {
   const files = [];
   let entries;
   try {
-    entries = fs.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    entries = fs2.readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
   } catch {
     return files;
   }
@@ -265,7 +370,7 @@ function snapshotRuleSource(source) {
     hash.update("\0");
     let content;
     try {
-      content = fs.readFileSync(file, "utf8");
+      content = fs2.readFileSync(file, "utf8");
     } catch {
       hash.update("missing");
       hash.update("\0");
@@ -307,8 +412,8 @@ function getAstGrepRuleFingerprint(projectRoot = process.cwd(), options = {}) {
   return ruleCorpusFingerprintForCycle("ast-grep", root, (fingerprintRoot) => sourceFingerprint(getAstGrepRuleSources(fingerprintRoot).map(snapshotRuleSource)), options.force);
 }
 function materializeMergedRuleDir(sources, mergedDir) {
-  fs.rmSync(mergedDir, { recursive: true, force: true });
-  fs.mkdirSync(mergedDir, { recursive: true });
+  fs2.rmSync(mergedDir, { recursive: true, force: true });
+  fs2.mkdirSync(mergedDir, { recursive: true });
   const claimedByEarlierSource = /* @__PURE__ */ new Set();
   for (const [sourceIndex, source] of sources.entries()) {
     const claimedThisSource = /* @__PURE__ */ new Set();
@@ -325,9 +430,9 @@ function materializeMergedRuleDir(sources, mergedDir) {
         continue;
       const destination = path.join(mergedDir, `source${sourceIndex}-${String(fileIndex).padStart(5, "0")}.yml`);
       if (survivingDocuments.length === file.documents.length) {
-        fs.copyFileSync(file.file, destination);
+        fs2.copyFileSync(file.file, destination);
       } else {
-        fs.writeFileSync(destination, `${survivingDocuments.map((document) => document.raw.trim()).join("\n---\n")}
+        fs2.writeFileSync(destination, `${survivingDocuments.map((document) => document.raw.trim()).join("\n---\n")}
 `);
       }
     }
@@ -343,14 +448,14 @@ function resolveBaselineSgconfig(projectRoot = process.cwd()) {
   const root = canonicalDir(path.resolve(projectRoot || process.cwd()));
   const fingerprint = getAstGrepRuleFingerprint(root, { force: true });
   const cached = cachedBaselines.get(root);
-  if (cached?.fingerprint === fingerprint && fs.existsSync(cached.path) && fs.existsSync(cached.mergedDir)) {
+  if (cached?.fingerprint === fingerprint && fs2.existsSync(cached.path) && fs2.existsSync(cached.mergedDir)) {
     return cached.path;
   }
   const sources = getAstGrepRuleSources(root).map(snapshotRuleSource);
   if (sources.length === 0)
     return void 0;
-  const dir = path.join(os.tmpdir(), "pi-lens-ast-grep");
-  fs.mkdirSync(dir, { recursive: true });
+  const dir = path.join(os2.tmpdir(), "pi-lens-ast-grep");
+  fs2.mkdirSync(dir, { recursive: true });
   const artifactKey = rootArtifactKey(root);
   const file = path.join(dir, `baseline-${process.pid}-${artifactKey}.sgconfig.yml`);
   const mergedDir = path.join(dir, `baseline-${process.pid}-${artifactKey}.rules`);
@@ -362,7 +467,7 @@ function resolveBaselineSgconfig(projectRoot = process.cwd()) {
   cleanupStaleBaselines(dir, protectedArtifacts);
   materializeMergedRuleDir(sources, mergedDir);
   const ruleDirForYaml = mergedDir.split(path.sep).join("/");
-  fs.writeFileSync(file, `ruleDirs:
+  fs2.writeFileSync(file, `ruleDirs:
   - ${JSON.stringify(ruleDirForYaml)}
 `);
   cachedBaselines.set(root, { fingerprint, path: file, mergedDir });
@@ -373,7 +478,7 @@ var SG_BASELINE_RETAINED_ENTRIES = 24;
 function enforceBaselineEntryCap(dir, keep) {
   let names;
   try {
-    names = fs.readdirSync(dir);
+    names = fs2.readdirSync(dir);
   } catch {
     return;
   }
@@ -389,7 +494,7 @@ function enforceBaselineEntryCap(dir, keep) {
     try {
       candidates.push({
         full,
-        mtimeMs: fs.statSync(full).mtimeMs,
+        mtimeMs: fs2.statSync(full).mtimeMs,
         recursive: isMergedDir
       });
     } catch {
@@ -402,7 +507,7 @@ function enforceBaselineEntryCap(dir, keep) {
   let evicted = 0;
   for (const candidate of candidates.slice(0, over)) {
     try {
-      fs.rmSync(candidate.full, {
+      fs2.rmSync(candidate.full, {
         recursive: candidate.recursive,
         force: true
       });
@@ -426,7 +531,7 @@ function enforceBaselineEntryCap(dir, keep) {
 function cleanupStaleBaselines(dir, keep) {
   try {
     const cutoff = Date.now() - 7 * 24 * 60 * 60 * 1e3;
-    for (const name of fs.readdirSync(dir)) {
+    for (const name of fs2.readdirSync(dir)) {
       const isConfig = /^baseline(?:-\d+(?:-[a-f0-9]+)?)?\.sgconfig\.yml$/.test(name);
       const isMergedDir = /^baseline-\d+(?:-[a-f0-9]+)?\.rules$/.test(name);
       if (!isConfig && !isMergedDir)
@@ -435,9 +540,9 @@ function cleanupStaleBaselines(dir, keep) {
       if (keep.has(full))
         continue;
       try {
-        const stat2 = fs.statSync(full);
+        const stat2 = fs2.statSync(full);
         if (stat2.mtimeMs < cutoff) {
-          fs.rmSync(full, { recursive: stat2.isDirectory(), force: true });
+          fs2.rmSync(full, { recursive: stat2.isDirectory(), force: true });
         }
       } catch {
       }
@@ -492,7 +597,7 @@ function serverTraits(declaration) {
 }
 
 // dist/clients/lsp/config.js
-import * as os3 from "node:os";
+import * as os4 from "node:os";
 import path3 from "node:path";
 
 // dist/clients/dispatch/known-runner-ids.js
@@ -510,12 +615,12 @@ function isKnownRunnerId(id) {
 // dist/clients/lsp/launch.js
 import { AsyncLocalStorage } from "node:async_hooks";
 import { execFileSync, spawn as nodeSpawn } from "node:child_process";
-import fs3 from "node:fs";
-import os2 from "node:os";
+import fs4 from "node:fs";
+import os3 from "node:os";
 import path2 from "node:path";
 
 // dist/clients/lsp/ruby-drive-dirs.js
-import * as fs2 from "node:fs";
+import * as fs3 from "node:fs";
 var RUBY_VERSION_DIR = /^ruby\d/i;
 var rubyDirNamesCache = new BoundedLruCache(16);
 function rubyDriveKey(driveRoot) {
@@ -531,7 +636,7 @@ function getRubyVersionDirNamesSync(driveRoot) {
     return cached;
   let names;
   try {
-    names = filterRubyDirNames(fs2.readdirSync(driveRoot));
+    names = filterRubyDirNames(fs3.readdirSync(driveRoot));
   } catch {
     names = [];
   }
@@ -545,7 +650,7 @@ async function getRubyVersionDirNamesAsync(driveRoot) {
     return cached;
   let names;
   try {
-    names = filterRubyDirNames(await fs2.promises.readdir(driveRoot));
+    names = filterRubyDirNames(await fs3.promises.readdir(driveRoot));
   } catch {
     names = [];
   }
@@ -572,8 +677,8 @@ function logSessionStart2(msg) {
   const line = redactSecrets(`[${(/* @__PURE__ */ new Date()).toISOString()}] ${msg}
 `);
   try {
-    fs3.mkdirSync(SESSIONSTART_LOG_DIR, { recursive: true });
-    fs3.appendFileSync(SESSIONSTART_LOG, line);
+    fs4.mkdirSync(SESSIONSTART_LOG_DIR, { recursive: true });
+    fs4.appendFileSync(SESSIONSTART_LOG, line);
   } catch {
   }
 }
@@ -654,7 +759,7 @@ async function buildAugmentedPath(basePath) {
     candidates.push(nodeDir);
   }
   if (isWindows) {
-    const home = os2.homedir();
+    const home = os3.homedir();
     const driveRoot = path2.parse(home).root;
     candidates.push(path2.join(home, ".cargo", "bin"));
     candidates.push(path2.join(home, "go", "bin"));
@@ -676,7 +781,7 @@ async function buildAugmentedPath(basePath) {
   }
   const toAppend = [];
   for (const candidate of candidates) {
-    if (!candidate || !fs3.existsSync(candidate))
+    if (!candidate || !fs4.existsSync(candidate))
       continue;
     const normalized = normalizePathEntry(candidate, process.platform);
     if (existing.has(normalized))
@@ -692,13 +797,13 @@ async function buildAugmentedPath(basePath) {
 }
 function isCmdShimValid(cmdPath) {
   try {
-    const content = fs3.readFileSync(cmdPath, "utf-8");
+    const content = fs4.readFileSync(cmdPath, "utf-8");
     const match = content.match(/"%~dp0[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
     if (!match)
       return true;
     const relPath = match[1].replace(/[/\\]/g, path2.sep);
     const target = path2.resolve(path2.dirname(cmdPath), "..", relPath);
-    return fs3.existsSync(target);
+    return fs4.existsSync(target);
   } catch {
     return true;
   }
@@ -715,16 +820,16 @@ function isMissingWindowsStartupCommand(command, spawnCommand, cwd, env) {
 }
 function bypassPs1OnWindows(ps1Path, args) {
   const cmdPath = `${ps1Path.slice(0, -4)}.cmd`;
-  if (fs3.existsSync(cmdPath)) {
+  if (fs4.existsSync(cmdPath)) {
     return { command: cmdPath, args, needsShell: true };
   }
   try {
-    const content = fs3.readFileSync(ps1Path, "utf-8");
+    const content = fs4.readFileSync(ps1Path, "utf-8");
     const match = content.match(/"\$basedir[/\\]\.\.[/\\]((?:[\w./@-]|\\)+\.(?:mjs|cjs|js))"/i);
     if (match) {
       const relPath = match[1].replace(/[/\\]/g, path2.sep);
       const jsPath = path2.resolve(path2.dirname(ps1Path), "..", relPath);
-      if (fs3.existsSync(jsPath)) {
+      if (fs4.existsSync(jsPath)) {
         return {
           command: process.execPath,
           args: [jsPath, ...args],
@@ -752,7 +857,7 @@ function findBinaryOnPath(command, env) {
       timeout: 5e3
     }).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     for (const candidate of result) {
-      if (fs3.existsSync(candidate)) {
+      if (fs4.existsSync(candidate)) {
         return candidate;
       }
     }
@@ -988,7 +1093,7 @@ async function launchLSP(command, args = [], options = {}) {
   };
   proc.stderr?.on("data", onStartupStderr);
   try {
-    await new Promise((resolve3, reject) => {
+    await new Promise((resolve4, reject) => {
       let settled = false;
       proc.on("error", (err) => {
         if (!settled) {
@@ -1025,7 +1130,7 @@ async function launchLSP(command, args = [], options = {}) {
       setTimeout(() => {
         if (!settled) {
           settled = true;
-          resolve3();
+          resolve4();
         }
       }, startupFailureWindowMs);
     });
@@ -1086,7 +1191,7 @@ function recordConfigResolved(cwd, resolution, lspConfig, homeDir, resolveMs) {
   });
   logSessionStart(`config resolved documents=${summary.documents.length} legacy=${legacyDocuments} records=${summary.recordCount} deniedServers=${deniedServers} resolveMs=${resolveMs} session=${sessionId} root=${root}`);
 }
-async function loadLSPConfig(cwd, homeDir = os3.homedir(), options = {}) {
+async function loadLSPConfig(cwd, homeDir = os4.homedir(), options = {}) {
   const reporting = options.report !== false;
   publishConfigResolutionPending(cwd);
   const resolveStartedAt = Date.now();
@@ -1447,7 +1552,7 @@ async function initLSPConfig(cwd) {
   if (existing)
     return existing;
   const promise = (async () => {
-    const config = registerLSPConfig(await loadLSPConfig(cwd, os3.homedir()));
+    const config = registerLSPConfig(await loadLSPConfig(cwd, os4.homedir()));
     forgetConfigResolvedClaims(setSessionRootConfig(normalizedCwd, config));
   })();
   configInFlight.set(normalizedCwd, promise);
@@ -1960,8 +2065,8 @@ function classifyCascadeWaitTier(lspService, filePath, snapshots) {
 }
 
 // dist/clients/lsp/lombok.js
-import * as fs4 from "node:fs";
-import * as os4 from "node:os";
+import * as fs5 from "node:fs";
+import * as os5 from "node:os";
 import * as path4 from "node:path";
 var LOMBOK_ENV_KEYS = ["PI_LENS_LOMBOK_JAR", "LOMBOK_JAR"];
 var LOMBOK_PROJECT_FILES = [
@@ -1975,17 +2080,17 @@ function fileExists(filePath) {
   if (!filePath)
     return false;
   try {
-    return fs4.statSync(filePath).isFile();
+    return fs5.statSync(filePath).isFile();
   } catch {
     return false;
   }
 }
 function readTextIfSmall(filePath, maxBytes = 512 * 1024) {
   try {
-    const stat2 = fs4.statSync(filePath);
+    const stat2 = fs5.statSync(filePath);
     if (!stat2.isFile() || stat2.size > maxBytes)
       return "";
-    return fs4.readFileSync(filePath, "utf-8");
+    return fs5.readFileSync(filePath, "utf-8");
   } catch {
     return "";
   }
@@ -2026,7 +2131,7 @@ function newestExistingJar(candidates) {
   let best;
   for (const candidate of candidates) {
     try {
-      const stat2 = fs4.statSync(candidate);
+      const stat2 = fs5.statSync(candidate);
       if (!stat2.isFile())
         continue;
       if (!best || stat2.mtimeMs > best.mtimeMs) {
@@ -2037,22 +2142,22 @@ function newestExistingJar(candidates) {
   }
   return best?.filePath;
 }
-function mavenLocalLombokJar(home = os4.homedir()) {
+function mavenLocalLombokJar(home = os5.homedir()) {
   const base = path4.join(home, ".m2", "repository", "org", "projectlombok", "lombok");
   let versions = [];
   try {
-    versions = fs4.readdirSync(base);
+    versions = fs5.readdirSync(base);
   } catch {
     return void 0;
   }
   return newestExistingJar(versions.map((version) => path4.join(base, version, `lombok-${version}.jar`)));
 }
-function gradleCacheLombokJar(home = os4.homedir()) {
+function gradleCacheLombokJar(home = os5.homedir()) {
   const base = path4.join(home, ".gradle", "caches", "modules-2", "files-2.1", "org.projectlombok", "lombok");
   const candidates = [];
   let versions = [];
   try {
-    versions = fs4.readdirSync(base);
+    versions = fs5.readdirSync(base);
   } catch {
     return void 0;
   }
@@ -2060,7 +2165,7 @@ function gradleCacheLombokJar(home = os4.homedir()) {
     const versionDir = path4.join(base, version);
     let hashes = [];
     try {
-      hashes = fs4.readdirSync(versionDir);
+      hashes = fs5.readdirSync(versionDir);
     } catch {
       continue;
     }
@@ -2097,7 +2202,7 @@ function createLombokJdtlsArgs(root, baseEnv = process.env) {
 
 // dist/clients/lsp/jvm-runtime.js
 import { existsSync as existsSync2, readdirSync as readdirSync4 } from "node:fs";
-import os5 from "node:os";
+import os6 from "node:os";
 import path5 from "node:path";
 var JAVA_EXE = process.platform === "win32" ? "java.exe" : "java";
 var JAVA_PROBE_TIMEOUT_MS = 5e3;
@@ -2125,7 +2230,7 @@ function childDirs(base) {
   }
 }
 function candidateRoots() {
-  const home = os5.homedir();
+  const home = os6.homedir();
   const roots = [];
   roots.push(path5.join(home, ".jdks"));
   roots.push(path5.join(getGlobalPiLensDir(), "tools"));
@@ -2422,8 +2527,8 @@ function posixFilesystemIsCaseInsensitive(root) {
   const alternatePath = path6.join(path6.dirname(resolved), alternate);
   if (alternate !== name && existsSync3(alternatePath)) {
     try {
-      const actual = statSync3(resolved);
-      const alternateStat = statSync3(alternatePath);
+      const actual = statSync4(resolved);
+      const alternateStat = statSync4(alternatePath);
       insensitive = actual.dev === alternateStat.dev && actual.ino === alternateStat.ino;
     } catch {
       insensitive = false;
@@ -3017,7 +3122,7 @@ function piAgentExtensionsRootKey(file) {
   return dirKey.slice(0, index + marker.length);
 }
 function IgnoreHomeRoot(primary) {
-  const homeKey = normalizeEphemeralMapKey(path6.resolve(os6.homedir()));
+  const homeKey = normalizeEphemeralMapKey(path6.resolve(os7.homedir()));
   return withRootMarkers(async (file) => {
     const root = await primary(file);
     if (!root)
@@ -3027,7 +3132,7 @@ function IgnoreHomeRoot(primary) {
 }
 function rubyBinCandidates(baseName) {
   const candidates = [];
-  const home = os6.homedir();
+  const home = os7.homedir();
   const isWin = process.platform === "win32";
   const ext = isWin ? ".bat" : "";
   candidates.push(path6.join(home, ".local", "share", "mise", "installs", "ruby", "bin", `${baseName}${ext}`));
@@ -3084,8 +3189,8 @@ function createInteractiveServer(spec) {
 function PriorityRoot(markerGroups, excludePatterns, stopDir) {
   const resolvers = markerGroups.map((markers) => NearestRoot(markers, excludePatterns, stopDir));
   return withRootMarkers(async (file) => {
-    for (const resolve3 of resolvers) {
-      const root = await resolve3(file);
+    for (const resolve4 of resolvers) {
+      const root = await resolve4(file);
       if (root)
         return root;
     }
@@ -3198,7 +3303,7 @@ function NearestRoot(includePatterns, excludePatterns, stopDir) {
           }
         }
         for (const pattern of includePatterns) {
-          if (await markerExists(currentDir, pattern) && (pattern !== ".git" || currentDir !== os6.tmpdir()) && !await isExcludedLspRoot(currentDir)) {
+          if (await markerExists(currentDir, pattern) && (pattern !== ".git" || currentDir !== os7.tmpdir()) && !await isExcludedLspRoot(currentDir)) {
             return enforceLspRootCeiling(currentDir, process.cwd(), file);
           }
         }
@@ -3246,13 +3351,13 @@ async function findAncestorFile(startDir, ...relativeSegments) {
   return findAncestorFileAmong(startDir, [relativeSegments]);
 }
 async function findAncestorFileAmong(startDir, candidateSegmentLists) {
-  const fs5 = await import("node:fs/promises");
+  const fs6 = await import("node:fs/promises");
   let currentDir = path6.resolve(startDir);
   while (!isAtOrAboveHomeDir(currentDir)) {
     for (const segments of candidateSegmentLists) {
       const candidate = path6.join(currentDir, ...segments);
       try {
-        await fs5.access(candidate);
+        await fs6.access(candidate);
         return candidate;
       } catch {
       }
@@ -3308,14 +3413,14 @@ async function typescriptVersionForTsc(tscPath) {
   return void 0;
 }
 async function findTsserverPath(root, allowInstall, options) {
-  const fs5 = await import("node:fs/promises");
-  const projectRoots = await Promise.all([root, options?.sessionRoot ?? process.cwd(), process.cwd()].map((dir) => fs5.realpath(dir).catch(() => path6.resolve(dir))));
+  const fs6 = await import("node:fs/promises");
+  const projectRoots = await Promise.all([root, options?.sessionRoot ?? process.cwd(), process.cwd()].map((dir) => fs6.realpath(dir).catch(() => path6.resolve(dir))));
   const admitCandidate = async (candidate, projectSupplied) => {
     try {
-      const real = await fs5.realpath(candidate);
-      if (path6.basename(real) !== "tsserver.js" || !(await fs5.stat(real)).isFile())
+      const real = await fs6.realpath(candidate);
+      if (path6.basename(real) !== "tsserver.js" || !(await fs6.stat(real)).isFile())
         return void 0;
-      const manifest = JSON.parse(await fs5.readFile(path6.join(path6.dirname(real), "..", "package.json"), "utf8"));
+      const manifest = JSON.parse(await fs6.readFile(path6.join(path6.dirname(real), "..", "package.json"), "utf8"));
       if (typeof manifest?.version !== "string" || !manifest.version)
         return void 0;
       return admitProjectSuppliedTsserver(real, options?.sessionRoot ?? process.cwd(), projectSupplied || projectRoots.some((dir) => isUnderDir(real, dir)), options?.projectCodeAllowed);
@@ -3331,7 +3436,7 @@ async function findTsserverPath(root, allowInstall, options) {
   }
   const cwdCandidate = path6.join(process.cwd(), "node_modules", "typescript", "lib", "tsserver.js");
   try {
-    await fs5.access(cwdCandidate);
+    await fs6.access(cwdCandidate);
     const admittedCwd = await admitCandidate(cwdCandidate, false);
     if (admittedCwd)
       return admittedCwd;
@@ -3422,7 +3527,7 @@ async function findNativeTypeScriptLsp(root) {
   return void 0;
 }
 function dotnetToolCandidates(tool) {
-  const home = os6.homedir();
+  const home = os7.homedir();
   return [
     path6.join(PI_LENS_BIN_DIR2, `${tool}.exe`),
     path6.join(PI_LENS_BIN_DIR2, tool),
@@ -3435,16 +3540,16 @@ function binExeVariants(dir, tool) {
   return process.platform === "win32" ? [path6.join(dir, `${tool}.exe`), path6.join(dir, tool)] : [path6.join(dir, tool)];
 }
 function goBinCandidates(tool) {
-  const gopath = process.env.GOPATH?.split(path6.delimiter)[0] || path6.join(os6.homedir(), "go");
+  const gopath = process.env.GOPATH?.split(path6.delimiter)[0] || path6.join(os7.homedir(), "go");
   return [tool, ...binExeVariants(path6.join(gopath, "bin"), tool)];
 }
 function cargoBinCandidates(tool) {
-  const cargoHome = process.env.CARGO_HOME || path6.join(os6.homedir(), ".cargo");
+  const cargoHome = process.env.CARGO_HOME || path6.join(os7.homedir(), ".cargo");
   return [tool, ...binExeVariants(path6.join(cargoHome, "bin"), tool)];
 }
 async function tryGemInstall(gem) {
-  const { join: join3 } = await import("node:path");
-  const binDir = join3(getGlobalPiLensDir(), "bin");
+  const { join: join4 } = await import("node:path");
+  const binDir = join4(getGlobalPiLensDir(), "bin");
   const { mkdir } = await import("node:fs/promises");
   await mkdir(binDir, { recursive: true });
   const result = await safeSpawnAsync("gem", ["install", gem, "--bindir", binDir, "--no-document"], { timeout: 18e4, ignoreAmbientSignal: true });
@@ -5062,6 +5167,9 @@ export {
   registerRunnerId,
   withLspProjectCodePermission,
   refuseUntrustedLspExecution,
+  resolveAnalysisRootPath,
+  resolveAnalysisRoot,
+  canWriteAnalysisRoot,
   BUILTIN_SERVER_RUNNER_COVERS,
   describeRootFallback,
   resolveLspServerCwd,