pi-lens 4.2.1 → 4.4.0

package/dist/clients/lsp/inferred-project.js

@@ -1,216 +0,0 @@
-/**
- * #1640: honest rendering for TypeScript diagnostics on files that belong to no
- * tsconfig project.
- *
- * When a file matches no project's `include`/`files`, tsserver still checks it —
- * in a synthetic INFERRED project with default compiler options, no `types`
- * from the project's `tsconfig`, and different module resolution. The project's
- * own `tsc --noEmit` never looks at those files, so the two answers legitimately
- * disagree. Presenting the inferred answer at full blocking authority tells the
- * agent that a gate failed when no gate ever ran.
- *
- * The fix is DEMOTE-WITH-LABEL, never suppress. The live #1640 triage found the
- * inferred-project batch was a MIX: some diagnostics were provably phantom
- * (missing test-runner globals, module resolution), and others were genuine type
- * errors the project's `tsc` gate cannot see precisely BECAUSE the files sit
- * outside every project. Suppression would hide the real ones. Blocking would
- * overstate confidence in the phantom ones. Demoting to warning and naming the
- * config gap preserves the signal and hands the verification burden to the
- * person who can close it.
- *
- * Every "we do not know" path leaves the diagnostics untouched. An unanswered
- * `projectInfo` probe is not a verdict (AGENTS.md shape 10).
- */
-import * as path from "node:path";
-import { fetchTsserverProjectIdentity, } from "./tsserver-sync.js";
-import { toProjectRelativePath } from "../path-utils.js";
-import { logLatency } from "../latency-logger.js";
-/**
- * The stable, greppable half of the label. Tests and renderers match on this;
- * the actionable `add <glob>` half varies per file.
- *
- * Sibling of `STALE_LINE_MARKER` (`clients/runtime-turn.ts`) — same idea: a
- * finding that survives at reduced authority says so in its own text, so no
- * downstream renderer has to be taught about the demotion separately.
- */
-export const INFERRED_PROJECT_MARKER = "not in any tsconfig project — checked with inferred settings";
-/** Extensions tsserver owns. A file outside this set never reaches the probe. */
-const TS_PROJECT_EXTENSIONS = new Set([
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-]);
-/**
- * `source` values the classic typescript-language-server stamps on its own
- * diagnostics. Auxiliary servers sharing the same result (opengrep, typos,
- * zizmor, ast-grep) carry their own source and are NOT affected by a tsconfig
- * gap, so they keep their severity.
- */
-const TYPESCRIPT_DIAGNOSTIC_SOURCES = new Set(["typescript", "ts", "tsserver"]);
-export function isTsProjectFile(filePath) {
-    return TS_PROJECT_EXTENSIONS.has(path.extname(filePath).toLowerCase());
-}
-function isTypeScriptSourcedDiagnostic(d) {
-    return TYPESCRIPT_DIAGNOSTIC_SOURCES.has((d.source ?? "").toLowerCase());
-}
-/**
- * The glob the user should add to a tsconfig `include`. A file at
- * `tests/unit/a.test.ts` yields `tests/**` — the top-level directory is what a
- * person actually adds, and it is what the #1640 report itself asked for. A
- * file sitting directly in the project root yields its own relative path, since
- * there is no containing directory to name.
- */
-export function suggestTsconfigInclude(filePath, cwd) {
-    const relative = toProjectRelativePath(filePath, cwd);
-    if (path.posix.isAbsolute(relative) || /^[A-Za-z]:/.test(relative)) {
-        // Outside the project root: name the file's own directory instead of
-        // inventing a root-relative glob that would not match anything.
-        const dir = relative.slice(0, relative.lastIndexOf("/"));
-        return dir ? `${dir}/**` : relative;
-    }
-    const segments = relative.split("/").filter(Boolean);
-    return segments.length > 1 ? `${segments[0]}/**` : relative;
-}
-/** The full label appended to a demoted diagnostic's message. */
-export function inferredProjectNotice(filePath, cwd) {
-    return `[${INFERRED_PROJECT_MARKER}; add ${suggestTsconfigInclude(filePath, cwd)} to a tsconfig for authoritative checking]`;
-}
-/**
- * Pure transform: demote every TypeScript-sourced ERROR to a warning and append
- * the label. Warnings, hints, and auxiliary-sourced findings are returned
- * untouched — they were never blockers, so relabelling them would be noise.
- *
- * Returns the SAME array reference when nothing changed, so callers can cheaply
- * skip rebuilding their result objects.
- */
-export function applyInferredProjectDemotion(diagnostics, filePath, cwd) {
-    if (!diagnostics.some(isDemotableDiagnostic))
-        return diagnostics;
-    const notice = inferredProjectNotice(filePath, cwd);
-    return diagnostics.map((d) => isDemotableDiagnostic(d)
-        ? { ...d, severity: 2, message: `${d.message} ${notice}` }
-        : d);
-}
-function isDemotableDiagnostic(d) {
-    return d.severity === 1 && isTypeScriptSourcedDiagnostic(d);
-}
-/**
- * Probe project membership for `filePath` and demote its diagnostics when
- * tsserver answers "inferred project".
- *
- * Short-circuits BEFORE any probe when there is nothing a demotion could change:
- * a non-TypeScript file, or a diagnostic list with no TypeScript-sourced error
- * in it. So a clean sweep pays nothing, and a sweep over 500 clean files issues
- * zero extra requests.
- */
-export async function demoteInferredProjectDiagnostics(diagnostics, options) {
-    const { filePath, cwd, service } = options;
-    if (!isTsProjectFile(filePath))
-        return diagnostics;
-    if (!diagnostics.some(isDemotableDiagnostic))
-        return diagnostics;
-    if (options.signal?.aborted)
-        return diagnostics;
-    const fetchIdentity = options.fetchIdentity ?? fetchTsserverProjectIdentity;
-    const cache = options.identityCache;
-    let identity;
-    if (cache?.has(filePath)) {
-        identity = cache.get(filePath);
-    }
-    else {
-        identity = await fetchIdentity(service, filePath);
-        cache?.set(filePath, identity);
-    }
-    // `undefined` (probe unavailable/failed) and "unassociated" (tsserver named
-    // no project at all) are both UNKNOWN, not "inferred". Demoting on either
-    // would downgrade real blockers on any server that does not speak the
-    // tsserverRequest escape hatch.
-    if (identity?.projectKind !== "inferred")
-        return diagnostics;
-    return applyInferredProjectDemotion(diagnostics, filePath, cwd);
-}
-/**
- * Cap on how many `projectInfo` probes one sweep may issue. Only files that
- * actually carry a TypeScript error probe at all, so on a healthy project this
- * is never approached. Past the cap, membership stays UNKNOWN and nothing is
- * demoted — the fail-safe direction is the pre-#1640 behavior, not a silent
- * mass demotion.
- */
-export const INFERRED_PROJECT_PROBE_BUDGET = 300;
-/**
- * Sweep-wide entry point: demote every result whose file tsserver owns only
- * through an inferred project. Sequential on purpose — the probes run against a
- * single-threaded tsserver, so fanning out would only queue behind itself.
- *
- * The identity memo is local to this call. A module-level cache would pin the
- * first sweep's verdict for the life of the process, and editing a tsconfig is
- * precisely what changes the answer.
- *
- * The loop honors the caller's abort signal between files. The sweep that
- * produced these results is itself signal-bounded, so continuing to probe after
- * an abort would spend budget on an answer nobody will read (#1645 review F1).
- */
-export async function demoteInferredProjectSweepResults(results, cwd, service, signal) {
-    if (typeof service?.executeReadOnlyCommandOnLiveClient !== "function") {
-        return results;
-    }
-    const startedAt = Date.now();
-    const identityCache = new Map();
-    const out = [];
-    let demotedFiles = 0;
-    let demotedDiagnostics = 0;
-    let budgetExhausted = false;
-    let aborted = false;
-    for (const result of results) {
-        const diagnostics = result.diagnostics ?? [];
-        if (signal?.aborted) {
-            // Carry the remaining results through UNCHANGED rather than dropping
-            // them — an abort must cost the demotion, never a finding.
-            aborted = true;
-            out.push(result);
-            continue;
-        }
-        if (identityCache.size >= INFERRED_PROJECT_PROBE_BUDGET &&
-            !identityCache.has(result.filePath)) {
-            budgetExhausted = true;
-            out.push(result);
-            continue;
-        }
-        const demoted = await demoteInferredProjectDiagnostics(diagnostics, {
-            filePath: result.filePath,
-            cwd,
-            service,
-            identityCache,
-            signal,
-        });
-        if (demoted === diagnostics) {
-            out.push(result);
-            continue;
-        }
-        demotedFiles += 1;
-        demotedDiagnostics += demoted.filter((d, i) => d !== diagnostics[i]).length;
-        out.push({ ...result, diagnostics: demoted });
-    }
-    if (demotedFiles > 0 || budgetExhausted || aborted) {
-        logLatency({
-            type: "phase",
-            phase: "lsp_inferred_project_demote",
-            filePath: cwd,
-            durationMs: Date.now() - startedAt,
-            metadata: {
-                filesConsidered: results.length,
-                filesProbed: identityCache.size,
-                demotedFiles,
-                demotedDiagnostics,
-                budgetExhausted,
-                aborted,
-            },
-        });
-    }
-    return out;
-}

package/dist/clients/lsp/jvm-runtime.js

@@ -1,298 +0,0 @@
-/**
- * JVM runtime discovery for language-runtime LSP servers (jdtls #241).
- *
- * jdtls is itself a Java application — its launcher invokes `java`. When `java`
- * is not on PATH (common on Windows, where the Adoptium/Microsoft installers do
- * NOT add themselves to PATH and leave JAVA_HOME unset), the server silently
- * fails to spawn (`no_clients`). Rather than make the user hand-edit PATH, this
- * discovers an already-installed JDK in the canonical per-platform locations and
- * returns a spawn-env overlay (`JAVA_HOME` + `<jdk>/bin` prepended to PATH) that
- * `launchLSP` merges in — so jdtls (and its child `java`) resolve the JDK.
- *
- * This is the discovery half of #241 (runtimeInstall + canonical bin discovery);
- * the download half (fetch a Temurin JDK when none is found) is deferred.
- */
-import { existsSync, readdirSync } from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { classifyProbeFailure, createAvailabilityLatch, logAvailabilityDecision, startHostStallSampler, } from "../dispatch/runners/utils/availability-policy.js";
-import { getGlobalPiLensDir } from "../file-utils.js";
-import { safeSpawnAsync } from "../safe-spawn.js";
-const JAVA_EXE = process.platform === "win32" ? "java.exe" : "java";
-const JAVA_PROBE_TIMEOUT_MS = 5_000;
-/** jdtls requires a JDK ≥ 17 to run; recent builds prefer 21. */
-const MIN_JAVA_MAJOR = 17;
-/**
- * Resolve a directory to a valid JDK home. Accepts either a JDK home directly
- * (`<dir>/bin/java`) or a macOS bundle (`<dir>/Contents/Home/bin/java`).
- */
-function jdkHomeFrom(dir) {
-    if (existsSync(path.join(dir, "bin", JAVA_EXE)))
-        return dir;
-    const macHome = path.join(dir, "Contents", "Home");
-    if (existsSync(path.join(macHome, "bin", JAVA_EXE)))
-        return macHome;
-    return undefined;
-}
-/**
- * Best-effort major-version parse from a JDK directory name, e.g.
- * `jdk-21.0.11.10-hotspot` → 21, `zulu-17` → 17, `jdk1.8.0_402` → 8. Returns 0
- * when unparseable (still a usable candidate, just lowest priority).
- */
-function parseMajorVersion(name) {
-    // Legacy "1.8.0" scheme (Java 8 and earlier): a "1." NOT preceded by another
-    // digit (so it never false-matches inside "21.0.11" or "jdk-11").
-    const legacy = name.match(/(?<!\d)1\.(\d+)/);
-    if (legacy)
-        return Number.parseInt(legacy[1], 10);
-    // Modern scheme: the first 1–2 digit run at a non-digit boundary (jdk-21 → 21).
-    const modern = name.match(/(?<!\d)(\d{1,2})/);
-    return modern ? Number.parseInt(modern[1], 10) : 0;
-}
-/** Immediate child directories of `base`, or [] if `base` is absent/unreadable. */
-function childDirs(base) {
-    try {
-        return readdirSync(base, { withFileTypes: true })
-            .filter((e) => e.isDirectory() || e.isSymbolicLink())
-            .map((e) => path.join(base, e.name));
-    }
-    catch {
-        return [];
-    }
-}
-/** Per-platform roots whose immediate children are individual JDK installs. */
-function candidateRoots() {
-    const home = os.homedir();
-    const roots = [];
-    // JetBrains and pi-lens managed (Tier 2 download target) — all platforms.
-    roots.push(path.join(home, ".jdks"));
-    roots.push(path.join(getGlobalPiLensDir(), "tools"));
-    if (process.platform === "win32") {
-        const progFiles = [
-            process.env.ProgramFiles,
-            process.env["ProgramFiles(x86)"],
-            process.env.ProgramW6432,
-            path.join(process.env.LOCALAPPDATA ?? path.join(home, "AppData", "Local"), "Programs"),
-        ].filter((p) => Boolean(p));
-        for (const base of progFiles) {
-            roots.push(path.join(base, "Eclipse Adoptium"));
-            roots.push(path.join(base, "Java"));
-            roots.push(path.join(base, "Microsoft"));
-            roots.push(path.join(base, "Zulu"));
-            roots.push(path.join(base, "Amazon Corretto"));
-            roots.push(path.join(base, "BellSoft"));
-        }
-    }
-    else if (process.platform === "darwin") {
-        roots.push("/Library/Java/JavaVirtualMachines");
-        roots.push(path.join(home, "Library", "Java", "JavaVirtualMachines"));
-        roots.push("/opt/homebrew/opt");
-        roots.push("/usr/local/opt");
-    }
-    else {
-        roots.push("/usr/lib/jvm");
-        roots.push("/usr/java");
-        roots.push("/opt/java");
-    }
-    return roots;
-}
-/**
- * Scan canonical locations (plus `JAVA_HOME`) for an installed JDK ≥ 17. Returns
- * the highest-version match, or undefined when none is found. Pure filesystem
- * stat/readdir — no spawning, no network.
- */
-export function discoverJdkHome(roots = candidateRoots(), javaHome = process.env.JAVA_HOME) {
-    const found = [];
-    if (javaHome) {
-        const resolved = jdkHomeFrom(javaHome);
-        // Trust an explicit JAVA_HOME regardless of how its name parses.
-        if (resolved)
-            found.push({ home: resolved, major: Number.MAX_SAFE_INTEGER });
-    }
-    for (const root of roots) {
-        for (const dir of childDirs(root)) {
-            const resolved = jdkHomeFrom(dir);
-            if (!resolved)
-                continue;
-            found.push({
-                home: resolved,
-                major: parseMajorVersion(path.basename(dir)),
-            });
-        }
-    }
-    // Require a parseable major ≥ 17 (jdtls's floor). An explicit JAVA_HOME is
-    // stamped MAX above, so it always passes regardless of how its name parses.
-    const usable = found.filter((c) => c.major >= MIN_JAVA_MAJOR);
-    if (usable.length === 0)
-        return undefined;
-    usable.sort((a, b) => b.major - a.major);
-    return usable[0].home;
-}
-let _cachedEnv;
-/**
- * Availability latch for the `java` PATH probe (#1538, the #1467 latch family's
- * benign-direction sibling). A stalled probe is not evidence the tool is
- * missing — only a genuine "not found" (or a genuinely resolvable `java`) is a
- * durable fact worth caching for the session. A transient verdict (timeout,
- * abort, host stall) expires on the shared cooldown and is re-probed on the
- * next demand instead of pinning whatever `JAVA_HOME` happened to be ambient.
- */
-const javaAvailabilityLatch = createAvailabilityLatch();
-/**
- * Shared spawn while a probe is in flight (#1538 follow-up). Without this, two
- * concurrent `resolveJavaRuntimeEnv` calls — e.g. a multi-root Java project
- * spawning jdtls per root — each fire their own 5 s `where`/`which java`, and
- * every expired cooldown reopens that window for the process's whole
- * lifetime, not just at startup.
- */
-let inFlightJavaProbe = null;
-export function _resetJvmRuntimeCacheForTests() {
-    _cachedEnv = undefined;
-    javaAvailabilityLatch.reset();
-    inFlightJavaProbe = null;
-}
-/**
- * Probe `java` on PATH, distinguishing a durable verdict (found, or genuinely
- * absent) from a transient probe failure. Returns `true`/`false` for a durable
- * verdict; `undefined` when the probe was transient — including a memo served
- * from mid-cooldown — so the caller must not treat this call as proof `java`
- * is absent.
- *
- * `AvailabilityLatch.read()` returns `false` (not `null`) for BOTH a durable
- * "not found" AND a transient verdict whose cooldown hasn't expired yet — the
- * latch's own contract is "cache a safe fallback answer for this call", not
- * "this is durable". Blindly forwarding that `false` as durable is exactly
- * the #1538 bug moved one call deeper: jdtls's failed-spawn retry
- * (`BROKEN_BASE_COOLDOWN_MS`, `clients/lsp/index.ts`) re-enters
- * `resolveJavaRuntimeEnv` ~15-20 s later — inside this probe's 30 s transient
- * cooldown — so the very first retry after a stall would otherwise still
- * launder into the permanent `_cachedEnv`. Only `javaAvailabilityLatch`'s own
- * `outcome` distinguishes the two; a durable verdict is never `"transient"`.
- */
-function probeJavaOnPath() {
-    const memo = javaAvailabilityLatch.read();
-    if (memo !== null) {
-        if (javaAvailabilityLatch.getOutcome() === "transient") {
-            // Served from the memo, but the cooldown from the earlier stall
-            // hasn't expired — this is NOT a durable verdict. Log it (otherwise
-            // this state leaves zero record in latency.log) and surface
-            // `undefined` so the caller never writes the session cache.
-            logAvailabilityDecision({
-                tool: "java",
-                verdict: "unavailable",
-                outcome: "transient",
-                cause: javaAvailabilityLatch.getCause() ?? "probe-timeout",
-                elapsedMs: 0,
-                latched: false,
-                retryAfterMs: Math.max(0, javaAvailabilityLatch.getRetryAtMs() - Date.now()),
-                budgetMs: JAVA_PROBE_TIMEOUT_MS,
-                // No probe ran here: the latch's own remembered cause is replayed
-                // as-is, so the call site is the one asserting it (#2209).
-                classifiedBy: "caller",
-            });
-            return Promise.resolve(undefined);
-        }
-        return Promise.resolve(memo);
-    }
-    if (inFlightJavaProbe)
-        return inFlightJavaProbe;
-    inFlightJavaProbe = runJavaProbe().finally(() => {
-        inFlightJavaProbe = null;
-    });
-    return inFlightJavaProbe;
-}
-/** The actual `where`/`which java` spawn + classification. Never call this
- * directly — go through `probeJavaOnPath()`, which memoizes and dedupes it. */
-async function runJavaProbe() {
-    const finder = process.platform === "win32" ? "where" : "which";
-    const startedAt = Date.now();
-    const sampler = startHostStallSampler();
-    let result;
-    let hostStallMs;
-    try {
-        result = await safeSpawnAsync(finder, ["java"], {
-            timeout: JAVA_PROBE_TIMEOUT_MS,
-        });
-    }
-    finally {
-        hostStallMs = sampler.stop();
-    }
-    const elapsedMs = Date.now() - startedAt;
-    if (result.status === 0 && !result.error) {
-        javaAvailabilityLatch.noteAvailable();
-        logAvailabilityDecision({
-            tool: "java",
-            verdict: "available",
-            outcome: "success",
-            cause: "ok",
-            elapsedMs,
-            latched: true,
-            hostStallMs,
-            budgetMs: JAVA_PROBE_TIMEOUT_MS,
-            classifiedBy: "probe",
-        });
-        return true;
-    }
-    // A `where`/`which` that ran fine and found nothing is a genuine absence,
-    // same as a pre-existing #1496/#1467 sibling; anything else (timeout,
-    // abort, host stall) is transient and must not latch.
-    const { outcome, cause } = classifyProbeFailure(result, {
-        hostStallMs,
-        unclassifiedFailureOutcome: "missing",
-    });
-    const retryAfterMs = javaAvailabilityLatch.noteUnavailable(outcome, cause);
-    logAvailabilityDecision({
-        tool: "java",
-        verdict: "unavailable",
-        outcome,
-        cause,
-        elapsedMs,
-        latched: outcome !== "transient",
-        hostStallMs,
-        ...(retryAfterMs > 0 && { retryAfterMs }),
-        budgetMs: JAVA_PROBE_TIMEOUT_MS,
-        classifiedBy: "probe",
-    });
-    return outcome === "transient" ? undefined : false;
-}
-/**
- * Spawn-env overlay that makes a JVM-gated server (jdtls) launch when `java`
- * isn't on PATH. Returns undefined when `java` is already resolvable (respect
- * the user's PATH java) or when no JDK can be discovered (fail as before).
- *
- * Memoized per process — but only once the verdict is durable. A JDK found by
- * filesystem discovery is always safe to cache immediately: `discoverJdkHome`
- * is pure stat/readdir, unaffected by the PATH probe's timing. When no JDK is
- * discovered AND the PATH probe was transient, nothing is cached — the next
- * call re-probes (respecting the latch's own cooldown) instead of pinning a
- * "no override" verdict that a stalled probe never earned (#1538).
- */
-export async function resolveJavaRuntimeEnv() {
-    if (_cachedEnv)
-        return _cachedEnv.value;
-    // `java` already on PATH — nothing to inject; defer to the user's runtime.
-    const javaOnPath = await probeJavaOnPath();
-    if (javaOnPath === true) {
-        _cachedEnv = { value: undefined };
-        return undefined;
-    }
-    const home = discoverJdkHome();
-    if (home) {
-        const binDir = path.join(home, "bin");
-        const currentPath = process.env.PATH ?? process.env.Path ?? "";
-        _cachedEnv = {
-            value: {
-                JAVA_HOME: home,
-                PATH: binDir + path.delimiter + currentPath,
-            },
-        };
-        return _cachedEnv.value;
-    }
-    // No JDK discovered. Cache "no override" only when the PATH probe gave a
-    // durable "not found" — a transient probe (timeout/host-stall) must not
-    // pin this session to `undefined` forever.
-    if (javaOnPath === false) {
-        _cachedEnv = { value: undefined };
-    }
-    return undefined;
-}

package/dist/clients/lsp/language.js

@@ -1,63 +0,0 @@
-import path from "node:path";
-import { getLanguageId as getKindLanguageId, SPECIAL_FILENAMES, } from "../file-kinds.js";
-import { getLspCapableKinds } from "../language-policy.js";
-import { EXTENSION_TO_LSP_ID } from "../language-registry.js";
-/**
- * Language ID Mappings for LSP
- *
- * Maps file extensions to LSP language identifiers.
- */
-/**
- * Extension -> LSP `languageId`, projected from the canonical language registry
- * (clients/language-registry.ts, #2424). One FileKind can span several LSP ids
- * (jsts covers typescript/typescriptreact/vue, cxx covers c and cpp) and the
- * protocol spells some of them differently from the canonical id
- * ("shellscript", not "shell"), so the registry carries an `lspId` column and
- * this map is a pure projection of it — `Readonly` because the projection is
- * `Object.freeze`d at the source (#2424 review, S4).
- *
- * #1545 added a derived per-kind fill-in on top of the then-hand-curated table:
- * powershell had no entry at all and cxx covered a third of its extensions, so
- * `didOpen` announced those files as "plaintext". Tolerance for that varies by
- * server — json/yaml/clangd answer the same either way, a DocumentSelector
- * server may not handle the document at all — so the id is sent correctly
- * rather than relied on being ignored. The registry now owns every extension of
- * every lspCapable kind, so that fill-in contributed ZERO entries and is gone
- * (#2424 review, named output a). The net it provided is now a test, not a
- * runtime `??=`: lsp-capable-seam-coverage's "maps every lspCapable kind's
- * extensions to an LSP language id" fails the moment the registry misses one,
- * which is the fix a silent per-kind fallback would have hidden.
- */
-export const LANGUAGE_EXTENSIONS = EXTENSION_TO_LSP_ID;
-/**
- * file-kinds.ts's basename classifier (Makefile, Dockerfile.<suffix>,
- * CMakeLists.txt, …) matches by regex, not literal filename, so it can't be
- * flattened into LANGUAGE_EXTENSIONS' literal-key map. Derived from
- * SPECIAL_FILENAMES — the same single source of truth detectFileKind() uses —
- * filtered to lspCapable kinds so a basename pattern that classifies into an
- * lspCapable kind always resolves a language id here too (#1594).
- */
-const BASENAME_LANGUAGE_PATTERNS = (() => {
-    const lspCapableKinds = new Set(getLspCapableKinds());
-    return SPECIAL_FILENAMES.filter(({ kind }) => lspCapableKinds.has(kind)).map(({ pattern, kind }) => ({
-        pattern,
-        languageId: getKindLanguageId(kind),
-    }));
-})();
-function getBasenameLanguageId(base) {
-    return BASENAME_LANGUAGE_PATTERNS.find(({ pattern }) => pattern.test(base))
-        ?.languageId;
-}
-/**
- * Get language ID for a file path
- */
-export function getLanguageId(filePath) {
-    const ext = path.extname(filePath).toLowerCase();
-    if (ext && LANGUAGE_EXTENSIONS[ext]) {
-        return LANGUAGE_EXTENSIONS[ext];
-    }
-    const base = path.basename(filePath);
-    return (LANGUAGE_EXTENSIONS[base] ??
-        LANGUAGE_EXTENSIONS[base.toLowerCase()] ??
-        getBasenameLanguageId(base));
-}