@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/language-policy.js

@@ -1,252 +0,0 @@
-export const LANGUAGE_POLICY = {
-    jsts: {
-        lspCapable: true,
-        startup: {
-            defaults: ["typescript-language-server", "biome"],
-            heavyScansRequireConfig: true,
-        },
-    },
-    python: {
-        lspCapable: true,
-        startup: {
-            defaults: ["pyright", "ruff"],
-        },
-    },
-    go: { lspCapable: true },
-    rust: { lspCapable: true },
-    cxx: { lspCapable: true },
-    cmake: { lspCapable: true },
-    fish: { lspCapable: true },
-    shell: { lspCapable: true, startup: { defaults: ["shellcheck"] } },
-    json: { lspCapable: true },
-    markdown: { lspCapable: true },
-    css: { lspCapable: true },
-    yaml: {
-        lspCapable: true,
-        startup: {
-            defaults: ["yamllint"],
-            heavyScansRequireConfig: true,
-        },
-    },
-    sql: {
-        lspCapable: false,
-        startup: {
-            defaults: ["sqlfluff"],
-            heavyScansRequireConfig: true,
-        },
-    },
-    ruby: {
-        lspCapable: true,
-        startup: {
-            defaults: ["rubocop"],
-            heavyScansRequireConfig: true,
-        },
-    },
-    html: { lspCapable: true },
-    docker: { lspCapable: true },
-    php: { lspCapable: true },
-    powershell: { lspCapable: true },
-    prisma: { lspCapable: true },
-    csharp: { lspCapable: true },
-    fsharp: { lspCapable: true },
-    java: { lspCapable: true },
-    kotlin: { lspCapable: true, startup: { defaults: ["ktlint"] } },
-    swift: { lspCapable: true },
-    dart: { lspCapable: true },
-    lua: { lspCapable: true },
-    zig: { lspCapable: true },
-    haskell: { lspCapable: true },
-    "helm-template": { lspCapable: false },
-    elixir: { lspCapable: true },
-    gleam: { lspCapable: true },
-    ocaml: { lspCapable: true },
-    clojure: { lspCapable: true },
-    cue: { lspCapable: true },
-    terraform: { lspCapable: true },
-    terragrunt: { lspCapable: false },
-    nix: { lspCapable: true },
-    toml: { lspCapable: true, startup: { defaults: ["taplo"] } },
-};
-const PRIMARY_DISPATCH_GROUPS = {
-    jsts: {
-        mode: "fallback",
-        runnerIds: ["lsp"],
-        filterKinds: ["jsts"],
-    },
-    python: {
-        mode: "all",
-        runnerIds: ["lsp", "pyright"],
-        filterKinds: ["python"],
-    },
-    go: { mode: "all", runnerIds: ["lsp", "go-vet"], filterKinds: ["go"] },
-    rust: {
-        mode: "all",
-        runnerIds: ["lsp", "rust-clippy"],
-        filterKinds: ["rust"],
-    },
-    ruby: {
-        mode: "all",
-        runnerIds: ["lsp", "rubocop"],
-        filterKinds: ["ruby"],
-    },
-    cxx: {
-        mode: "all",
-        runnerIds: ["lsp", "cpp-check"],
-        filterKinds: ["cxx"],
-    },
-    cmake: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["cmake"] },
-    fish: {
-        mode: "all",
-        runnerIds: ["lsp", "fish-indent"],
-        filterKinds: ["fish"],
-    },
-    shell: {
-        mode: "all",
-        runnerIds: ["lsp", "shellcheck"],
-        filterKinds: ["shell"],
-    },
-    json: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["json"] },
-    markdown: {
-        // marksman (primary LSP) adds cross-file checks the cold spellcheck/vale
-        // runners can't see; all three run so prose + structural coverage coexist.
-        mode: "all",
-        runnerIds: ["lsp", "spellcheck", "vale"],
-        filterKinds: ["markdown"],
-    },
-    css: {
-        mode: "all",
-        runnerIds: ["lsp", "stylelint"],
-        filterKinds: ["css"],
-    },
-    yaml: {
-        mode: "all",
-        runnerIds: ["lsp", "yamllint", "trivy-config", "helm-lint", "helm-render"],
-        filterKinds: ["yaml"],
-    },
-    sql: {
-        mode: "fallback",
-        runnerIds: ["sqlfluff"],
-        filterKinds: ["sql"],
-    },
-    html: {
-        mode: "all",
-        runnerIds: ["lsp", "htmlhint"],
-        filterKinds: ["html"],
-    },
-    docker: {
-        mode: "all",
-        runnerIds: ["lsp", "hadolint", "trivy-config"],
-        filterKinds: ["docker"],
-    },
-    php: {
-        mode: "fallback",
-        runnerIds: ["lsp", "php-lint", "phpstan"],
-        filterKinds: ["php"],
-    },
-    powershell: {
-        mode: "all",
-        runnerIds: ["lsp", "psscriptanalyzer"],
-        filterKinds: ["powershell"],
-    },
-    prisma: {
-        mode: "all",
-        runnerIds: ["lsp", "prisma-validate"],
-        filterKinds: ["prisma"],
-    },
-    csharp: {
-        mode: "fallback",
-        runnerIds: ["lsp", "dotnet-build"],
-        filterKinds: ["csharp"],
-    },
-    fsharp: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["fsharp"] },
-    java: {
-        mode: "fallback",
-        runnerIds: ["lsp", "javac"],
-        filterKinds: ["java"],
-    },
-    kotlin: {
-        mode: "all",
-        runnerIds: ["lsp", "ktlint"],
-        filterKinds: ["kotlin"],
-    },
-    swift: {
-        mode: "all",
-        runnerIds: ["lsp", "swiftlint"],
-        filterKinds: ["swift"],
-    },
-    dart: {
-        mode: "all",
-        runnerIds: ["lsp", "dart-analyze"],
-        filterKinds: ["dart"],
-    },
-    lua: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["lua"] },
-    zig: { mode: "all", runnerIds: ["lsp", "zig-check"], filterKinds: ["zig"] },
-    haskell: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["haskell"] },
-    "helm-template": {
-        mode: "all",
-        // helm-render is opt-in (`helm.renderValidation.enabled`) and skips itself
-        // when the switch is absent, so it costs nothing when unconfigured (#1283).
-        runnerIds: ["helm-lint", "helm-render"],
-        filterKinds: ["helm-template"],
-    },
-    elixir: {
-        mode: "all",
-        runnerIds: ["lsp", "elixir-check", "credo"],
-        filterKinds: ["elixir"],
-    },
-    gleam: {
-        mode: "all",
-        runnerIds: ["lsp", "gleam-check"],
-        filterKinds: ["gleam"],
-    },
-    ocaml: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["ocaml"] },
-    clojure: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["clojure"] },
-    // #1522: cuelsp reports syntax/parse errors only; cue-vet covers the
-    // evaluation-error class the language server deliberately doesn't publish.
-    cue: { mode: "all", runnerIds: ["lsp", "cue-vet"], filterKinds: ["cue"] },
-    terraform: {
-        mode: "all",
-        runnerIds: ["lsp", "tflint", "trivy-config"],
-        filterKinds: ["terraform"],
-    },
-    terragrunt: {
-        mode: "all",
-        runnerIds: ["terragrunt"],
-        filterKinds: ["terragrunt"],
-    },
-    nix: { mode: "fallback", runnerIds: ["lsp"], filterKinds: ["nix"] },
-    toml: {
-        mode: "all",
-        runnerIds: ["lsp", "taplo"],
-        filterKinds: ["toml"],
-    },
-};
-export function getLspCapableKinds() {
-    return Object.keys(LANGUAGE_POLICY).filter((kind) => LANGUAGE_POLICY[kind].lspCapable);
-}
-export function getPrimaryDispatchGroup(kind, lspEnabled) {
-    const base = PRIMARY_DISPATCH_GROUPS[kind];
-    if (!base)
-        return undefined;
-    const ids = lspEnabled
-        ? [...base.runnerIds]
-        : base.runnerIds.filter((id) => id !== "lsp");
-    if (ids.length === 0)
-        return undefined;
-    return {
-        mode: base.mode,
-        runnerIds: ids,
-        filterKinds: base.filterKinds,
-        semantic: base.semantic,
-    };
-}
-// Note: getStartupDefaultsForProfile has been moved to language-profile.ts as getDefaultStartupTools
-// Import from there if needed: import { getDefaultStartupTools } from "./language-profile.js"
-export function canRunStartupHeavyScans(profile, kind) {
-    if (!profile.present[kind])
-        return false;
-    const needsConfig = LANGUAGE_POLICY[kind].startup?.heavyScansRequireConfig;
-    if (!needsConfig)
-        return true;
-    return !!profile.configured[kind];
-}

package/node_modules/pi-lens/dist/clients/language-profile.js

@@ -1,361 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { CODE_KINDS, detectFileKind, DOTNET_CSHARP_ROOT_MARKERS, DOTNET_FSHARP_ROOT_MARKERS, KIND_EXTENSIONS, TERRAGRUNT_FILENAMES, } from "./file-kinds.js";
-import { getProjectIgnoreMatcher } from "./file-utils.js";
-import { direntsHaveMarkerGlobMatch, normalizeMapKey } from "./path-utils.js";
-import { LANGUAGE_POLICY, } from "./language-policy.js";
-import { getSourceFiles } from "./scan-utils.js";
-import { readDirEntriesSafe, shouldRecurseIntoDir } from "./source-walker.js";
-import { findNearestDirWithAnyBasename, registerWorkspaceTopologyReset, } from "./workspace-topology.js";
-import { BoundedLruCache } from "./bounded-cache.js";
-/** Every registered kind participates in project-language detection (#894). */
-export const SUPPORTED_FILE_KINDS = Object.keys(KIND_EXTENSIONS);
-const PROJECT_MARKERS_BY_KIND = {
-    jsts: ["package.json", "tsconfig.json", "jsconfig.json"],
-    python: ["pyproject.toml", "requirements.txt", "setup.py", "setup.cfg"],
-    go: ["go.mod"],
-    rust: ["Cargo.toml"],
-    cxx: [
-        "compile_commands.json",
-        "compile_flags.txt",
-        ".clangd",
-        "CMakeLists.txt",
-        "Makefile",
-        "makefile",
-        "meson.build",
-        "build.ninja",
-    ],
-    ruby: ["Gemfile", "Rakefile"],
-    yaml: [".yamllint", "yamllint.yaml", "yamllint.yml", "pyproject.toml"],
-    sql: [".sqlfluff", "pyproject.toml"],
-    php: ["composer.json", "composer.lock"],
-    prisma: ["schema.prisma", "prisma/schema.prisma"],
-    // #2870: `build.gradle.kts` is the Kotlin-DSL spelling of `build.gradle`
-    // and marks a Java module just as well — its absence here (and in
-    // ROOT_MARKERS_BY_KIND below) is what left a `.java` file in a
-    // Kotlin-DSL Gradle module resolving to the workspace root, where a
-    // polyglot repo's go.mod then claimed it. `kotlin` already lists both
-    // spellings; java listed only the Groovy one.
-    java: ["pom.xml", "build.gradle", "build.gradle.kts", ".classpath"],
-    kotlin: ["build.gradle.kts", "build.gradle", "pom.xml"],
-    swift: ["Package.swift"],
-    dart: ["pubspec.yaml"],
-    elixir: ["mix.exs"],
-    cue: ["cue.mod"],
-    gleam: ["gleam.toml"],
-    terraform: [".terraform.lock.hcl"],
-    terragrunt: TERRAGRUNT_FILENAMES,
-    nix: ["flake.nix"],
-    toml: ["pyproject.toml", "Cargo.toml", "taplo.toml"],
-    csharp: DOTNET_CSHARP_ROOT_MARKERS,
-    fsharp: DOTNET_FSHARP_ROOT_MARKERS,
-};
-const ROOT_MARKERS_BY_KIND = {
-    jsts: [
-        "biome.json",
-        "biome.jsonc",
-        "package.json",
-        "tsconfig.json",
-        "jsconfig.json",
-        "pnpm-workspace.yaml",
-    ],
-    python: [
-        "pyproject.toml",
-        "requirements.txt",
-        "setup.py",
-        "setup.cfg",
-        "Pipfile",
-    ],
-    go: ["go.work", "go.mod", "go.sum"],
-    rust: ["Cargo.toml"],
-    cxx: [
-        "compile_commands.json",
-        "compile_flags.txt",
-        ".clangd",
-        "CMakeLists.txt",
-        "Makefile",
-        "makefile",
-        "meson.build",
-        "build.ninja",
-        ".git",
-    ],
-    ruby: ["Gemfile", "Rakefile"],
-    yaml: [".yamllint", ".yamllint.yml", ".yamllint.yaml"],
-    sql: [".sqlfluff", "pyproject.toml", "setup.cfg", "tox.ini"],
-    php: ["composer.json", "composer.lock"],
-    prisma: ["prisma/schema.prisma", "schema.prisma"],
-    // #2870: see PROJECT_MARKERS_BY_KIND.java above — this is the table
-    // `resolveLanguageRootForFile` walks, so the missing Kotlin-DSL spelling
-    // is what anchored a nested Gradle module's `.java` file at the
-    // workspace root.
-    java: ["pom.xml", "build.gradle", "build.gradle.kts", ".classpath"],
-    kotlin: ["build.gradle.kts", "build.gradle", "pom.xml"],
-    swift: ["Package.swift"],
-    dart: ["pubspec.yaml"],
-    elixir: ["mix.exs"],
-    cue: ["cue.mod", ".git"],
-    gleam: ["gleam.toml"],
-    terraform: [".terraform.lock.hcl"],
-    terragrunt: TERRAGRUNT_FILENAMES,
-    nix: ["flake.nix"],
-    toml: ["pyproject.toml", "Cargo.toml", "taplo.toml"],
-    csharp: DOTNET_CSHARP_ROOT_MARKERS,
-    fsharp: DOTNET_FSHARP_ROOT_MARKERS,
-};
-// Tool-owned configuration belongs beside the shared language vocabulary, but
-// not in ROOT_MARKERS_BY_KIND: these files are discovered by the tool, not by
-// the language root detector. Keeping them here lets runner cwd resolution
-// consume one canonical vocabulary without restoring a second seam-local map.
-const TOOL_MARKERS_BY_RUNNER = {
-    ruff: ["ruff.toml", ".ruff.toml"],
-    oxlint: [".oxlintrc.json", "oxlint.config.js"],
-    "spellcheck/typos": ["_typos.toml", "typos.toml"],
-    yamllint: ["yamllint.yaml", "yamllint.yml"],
-    prettier: [".prettierignore"],
-};
-/** Return the one shared marker vocabulary used to anchor this file kind. */
-export function rootMarkersForFile(filePath, runner) {
-    const kind = detectFileKind(path.resolve(filePath));
-    const languageMarkers = kind ? (ROOT_MARKERS_BY_KIND[kind] ?? []) : [];
-    const toolMarkers = runner ? (TOOL_MARKERS_BY_RUNNER[runner] ?? []) : [];
-    return toolMarkers.length
-        ? [...new Set([...languageMarkers, ...toolMarkers])]
-        : languageMarkers;
-}
-function hasProjectMarker(projectRoot, marker) {
-    if (!marker.includes("*"))
-        return fs.existsSync(path.join(projectRoot, marker));
-    try {
-        return direntsHaveMarkerGlobMatch(fs.readdirSync(projectRoot, { withFileTypes: true }), marker);
-    }
-    catch {
-        return false;
-    }
-}
-// Session-lifetime memo keyed on projectRoot. The topology-reset registry
-// clears it at session start. Only populated when the
-// caller did not pass an explicit `sourceFiles` array — the explicit-array
-// case is used by the warmup pipeline to inject pre-collected files and
-// must not pollute the no-arg cache. The synchronous getSourceFiles() call
-// inside this function does the same expensive ignoreMatcher-driven walk
-// as resolveStartupScanContext, so the same memo strategy applies.
-const languageProfileCache = new BoundedLruCache(32);
-registerWorkspaceTopologyReset(() => languageProfileCache.clear());
-export function detectProjectLanguageProfile(projectRoot, sourceFiles) {
-    if (sourceFiles === undefined) {
-        const cached = languageProfileCache.get(normalizeMapKey(projectRoot));
-        if (cached)
-            return cached;
-    }
-    const result = computeProjectLanguageProfile(projectRoot, sourceFiles);
-    if (sourceFiles === undefined) {
-        languageProfileCache.set(normalizeMapKey(projectRoot), result);
-    }
-    return result;
-}
-function computeProjectLanguageProfile(projectRoot, sourceFiles) {
-    const present = Object.fromEntries(SUPPORTED_FILE_KINDS.map((kind) => [kind, false]));
-    const counts = {};
-    const configured = {};
-    for (const [kind, markers] of Object.entries(PROJECT_MARKERS_BY_KIND)) {
-        if (!markers)
-            continue;
-        for (const marker of markers) {
-            if (hasProjectMarker(projectRoot, marker)) {
-                present[kind] = true;
-                configured[kind] = true;
-                break;
-            }
-        }
-    }
-    let files = sourceFiles;
-    if (!files) {
-        try {
-            files = getSourceFiles(projectRoot, true);
-        }
-        catch {
-            files = [];
-        }
-    }
-    for (const file of files) {
-        const kind = detectFileKind(file);
-        if (!kind)
-            continue;
-        present[kind] = true;
-        counts[kind] = (counts[kind] ?? 0) + 1;
-    }
-    const detectedKinds = SUPPORTED_FILE_KINDS.filter((kind) => present[kind]);
-    return {
-        present,
-        configured,
-        counts,
-        detectedKinds,
-    };
-}
-export function getDefaultStartupTools(profile) {
-    const tools = new Set();
-    for (const kind of Object.keys(LANGUAGE_POLICY)) {
-        if (!profile.present[kind])
-            continue;
-        const defaults = LANGUAGE_POLICY[kind].startup?.defaults ?? [];
-        for (const tool of defaults) {
-            if (LANGUAGE_POLICY[kind].startup?.heavyScansRequireConfig &&
-                !profile.configured[kind]) {
-                continue;
-            }
-            tools.add(tool);
-        }
-    }
-    return [...tools];
-}
-export function resolveLanguageRootForFile(filePath, workspaceRoot) {
-    const absoluteFilePath = path.resolve(filePath);
-    const startDir = path.dirname(absoluteFilePath);
-    const kind = detectFileKind(absoluteFilePath);
-    if (!kind)
-        return path.resolve(workspaceRoot);
-    const markers = rootMarkersForFile(absoluteFilePath);
-    if (!markers || markers.length === 0) {
-        return path.resolve(workspaceRoot);
-    }
-    // #807: nearest-marker discovery now shares workspace-topology.ts's single
-    // walk/cache/invalidation seam instead of this file's own per-kind
-    // `existsSync` climb loop. `findNearestDirWithAnyBasename` additionally
-    // rejects a marker at/above `$HOME` (the pre-#807 loop didn't), matching
-    // the AGENTS.md walker invariant — harmless here because the
-    // workspace-relative check right below already discards any candidate
-    // outside `workspaceRoot`, and `workspaceRoot` is never at/above `$HOME`
-    // in practice. This keeps resolveLanguageRootForFile's OWN stricter
-    // workspace-relative policy check unchanged: the topology service only
-    // supplies discovery, not this function's policy.
-    const found = findNearestDirWithAnyBasename(startDir, markers);
-    if (!found)
-        return path.resolve(workspaceRoot);
-    const workspace = path.resolve(workspaceRoot);
-    const relative = path.relative(workspace, found);
-    if (relative.startsWith("..") || path.isAbsolute(relative)) {
-        return workspace;
-    }
-    return found;
-}
-// ---------------------------------------------------------------------------
-// Async, chunked-yield variant for the cold-start warmup pipeline. See
-// startup-scan.ts comments and runtime-session.ts handleSessionStart for the
-// rationale; this is the same idea applied to the language-profile walk.
-//
-// We collect source files in a way that mirrors the sync `getSourceFiles` /
-// `collectSourceFiles` chain but yields to the event loop every N entries.
-// The collected file list is then handed to the existing sync
-// `detectProjectLanguageProfile` (which is fast once it doesn't need to walk
-// the tree itself), and the result is stored in the shared
-// `languageProfileCache` so the subsequent sync caller skips the walk.
-// ---------------------------------------------------------------------------
-// Keep the warmup walker lightweight (no source-filter dependency), but derive
-// its extension gate from the same authority as every other project-wide
-// enumeration. Generated-artifact filtering remains intentionally absent here:
-// warmup only needs language presence and never opens file contents.
-export const WARMUP_SOURCE_EXTS = new Set(SUPPORTED_FILE_KINDS.flatMap((kind) => KIND_EXTENSIONS[kind]));
-// Extensions belonging to CODE_KINDS — same derivation, used to give program
-// source priority within the capped warmup budget (#894 review, see below).
-const WARMUP_CODE_EXTS = new Set(SUPPORTED_FILE_KINDS.filter((kind) => CODE_KINDS.has(kind)).flatMap((kind) => KIND_EXTENSIONS[kind]));
-// Language detection needs which languages are PRESENT, not every file — so the
-// warmup walk is hard-capped. Without this, a walk rooted at a too-broad directory
-// (e.g. $HOME, if startup-scan's canWarmCaches guard is bypassed) traverses the
-// entire tree — #250's multi-hour home-dir scans. Generous enough to detect every
-// language present in any real project (mirrors startup-scan's 2000 limit).
-const MAX_WARMUP_SOURCE_FILES = 2000;
-// Total matched-file ceiling for the warmup walk, as a multiple of `maxFiles`
-// (#894 review): with per-category budgets the walk no longer stops at the
-// first `maxFiles` matches, so this keeps its total work deterministic —
-// at the default budget it tolerates up to ~20k data/doc files ahead of the
-// code dirs before giving up on finding more code files.
-const MATCHED_FILES_CEILING_FACTOR = 10;
-export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP_SOURCE_FILES, yieldEvery = 100) {
-    const root = path.resolve(rootDir);
-    const ignoreMatcher = getProjectIgnoreMatcher(root);
-    // #703: prime the tracked-files set once before the walk so a tracked file
-    // matching a `.gitignore`/global pattern still counts toward language
-    // detection. Fail-open on no-git/spawn failure.
-    await ignoreMatcher.ensureTrackedIndex();
-    const stack = [root];
-    // #894 review: `maxFiles` is a PER-CATEGORY budget — code kinds and
-    // data/doc kinds (NON_CODE_KINDS: json/yaml/markdown/…) fill separate
-    // buffers. With a single shared budget, 2000+ locale/fixture JSON files
-    // encountered before the code dirs exhausted the cap and flipped
-    // `present[kind]` to false for the project's real languages. Each buffer
-    // keeps the original #250 cap; the walk stops once the code budget is
-    // full (real languages are then detected; extra non-code presence can't
-    // justify more walking) or after `MATCHED_FILES_CEILING_FACTOR * maxFiles`
-    // matching files total — a deterministic work bound in the same spirit as
-    // #250's cap, generous enough that a locale/fixture pile ahead of the code
-    // dirs can't starve detection, tight enough that a misrooted /
-    // data-dominated tree stays bounded (#250/#758 class).
-    const codeOut = [];
-    const nonCodeOut = [];
-    let matchedSeen = 0;
-    let processedSinceYield = 0;
-    walk: while (stack.length > 0) {
-        const current = stack.pop();
-        if (!current)
-            continue;
-        const entries = readDirEntriesSafe(current);
-        for (const entry of entries) {
-            const fullPath = path.join(current, entry.name);
-            if (entry.isDirectory()) {
-                // Never checked symlinks — always follows them (unlike
-                // source-filter.ts's collectSourceFiles*, refs #191).
-                if (!shouldRecurseIntoDir(entry, fullPath, {
-                    ignoreMatcher,
-                    followSymlinks: true,
-                })) {
-                    continue;
-                }
-                stack.push(fullPath);
-            }
-            else if (entry.isFile()) {
-                // #1974: cheap extension gate before the ignore matcher — isIgnored is
-                // O(ancestorDirs x patterns) with a per-call minimatch regex compile
-                // (0.68-0.93ms/file, measured), so pay it only for files that already
-                // pass the extension check. A large ignored-but-not-dir-prunable pile
-                // (e.g. wal/*.log) otherwise pays the full isIgnored cost per file.
-                const ext = path.extname(entry.name).toLowerCase();
-                if (!WARMUP_SOURCE_EXTS.has(ext))
-                    continue;
-                if (ignoreMatcher.isIgnored(fullPath, false))
-                    continue;
-                matchedSeen += 1;
-                const bucket = WARMUP_CODE_EXTS.has(ext) ? codeOut : nonCodeOut;
-                // Per-category hard cap — language detection only needs
-                // presence (#250), so overflowing files of a full category
-                // are dropped rather than evicting the other category.
-                if (bucket.length < maxFiles)
-                    bucket.push(fullPath);
-                if (codeOut.length >= maxFiles ||
-                    matchedSeen >= MATCHED_FILES_CEILING_FACTOR * maxFiles) {
-                    break walk;
-                }
-            }
-            // Each iteration performs only bounded dirent/ext/ignore checks. Keep the
-            // count cadence: the cost does not scale with the corpus item size, and
-            // this walk's existing matched-file ceiling bounds the total work.
-            if (++processedSinceYield % yieldEvery === 0) {
-                // See countSourceFilesWithinLimitAsync for why setImmediate.
-                await new Promise((resolve) => setImmediate(resolve));
-            }
-        }
-    }
-    return [...codeOut, ...nonCodeOut];
-}
-export async function detectProjectLanguageProfileAsync(projectRoot) {
-    const cached = languageProfileCache.get(normalizeMapKey(projectRoot));
-    if (cached)
-        return cached;
-    const files = await collectSourceFilesForWarmup(projectRoot);
-    // Hand the pre-collected file list to the sync detector so it skips its
-    // own (synchronous) tree walk. The detector still does the file-marker
-    // probe (`existsSync` for package.json / pyproject.toml / etc.) which
-    // is constant-time and cheap.
-    const result = detectProjectLanguageProfile(projectRoot, files);
-    languageProfileCache.set(normalizeMapKey(projectRoot), result);
-    return result;
-}