pi-lens 3.8.73 → 3.8.74

package/dist/clients/knip-client.js

@@ -22,6 +22,38 @@ const EMPTY_RESULT = {
     unlistedDeps: [],
 };
 const ANALYSIS_TIMEOUT_MS = 30_000;
+/**
+ * Every package name referenced as a KEY (at any nesting depth — npm's
+ * `overrides` and pnpm's `pnpm.overrides` allow nested "for this dependency's
+ * sub-dependency" overrides) in `package.json`'s `overrides`, `resolutions`
+ * (Yarn's equivalent), or `pnpm.overrides` fields. These are the project's
+ * own explicit signal that a package is deliberately present to pin a
+ * resolution — not a source-imported dependency knip's import graph can see.
+ * Missing/malformed `package.json` degrades to an empty set (never throws) —
+ * this is a best-effort narrowing, not a required input.
+ */
+export function readOverridePinnedPackageNames(targetDir) {
+    const names = new Set();
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(path.join(targetDir, "package.json"), "utf-8"));
+    }
+    catch {
+        return names;
+    }
+    const collectKeys = (value) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        for (const [key, nested] of Object.entries(value)) {
+            names.add(key);
+            collectKeys(nested);
+        }
+    };
+    collectKeys(pkg.overrides);
+    collectKeys(pkg.resolutions);
+    collectKeys(pkg.pnpm?.overrides);
+    return names;
+}
 // --- Client ---
 export class KnipClient {
     knipAvailable = null;
@@ -206,7 +238,38 @@ export class KnipClient {
                 summary: "No issues found",
             };
         }
-        return this.parseOutput(output);
+        return this.dropOverridePinnedDeps(this.parseOutput(output), targetDir);
+    }
+    /**
+     * Drop `dependency`/`devDependency` issues for a package that's also
+     * referenced as an npm `overrides` (or Yarn `resolutions` / pnpm
+     * `pnpm.overrides`) key in this project's `package.json` (#968).
+     *
+     * A direct devDependency whose only job is pinning a vulnerable
+     * transitive/peer resolution has no source import — that's WORKING AS
+     * INTENDED, not dead code, and knip has no concept of "this dependency
+     * exists only to satisfy an overrides entry" (it only sees imports).
+     * `overrides`/`resolutions` are the project's own explicit, unambiguous
+     * signal that the package is deliberately present — the same class of
+     * signal `hardcoded-url`'s `SCREAMING_SNAKE_CASE` constant-name carve-out
+     * and `ts-ssrf`'s constant-identifier carve-out lean on elsewhere in this
+     * codebase — so this narrows the finding rather than suppressing
+     * `dependency`/`devDependency` issues wholesale: a devDependency that
+     * ISN'T also an overrides/resolutions key is still reported.
+     */
+    dropOverridePinnedDeps(result, targetDir) {
+        if (result.unusedDeps.length === 0)
+            return result;
+        const pinned = readOverridePinnedPackageNames(targetDir);
+        if (pinned.size === 0)
+            return result;
+        const isPinnedDepIssue = (issue) => (issue.type === "dependency" || issue.type === "devDependency") &&
+            (pinned.has(issue.name) || (!!issue.package && pinned.has(issue.package)));
+        const issues = result.issues.filter((issue) => !isPinnedDepIssue(issue));
+        const unusedDeps = result.unusedDeps.filter((issue) => !isPinnedDepIssue(issue));
+        return unusedDeps.length === result.unusedDeps.length
+            ? result
+            : { ...result, issues, unusedDeps };
     }
     async getKnipEnvironment(targetDir) {
         const { getToolEnvironment } = await import("./installer/index.js");

package/dist/clients/language-profile.js

@@ -1,48 +1,14 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { detectFileKind } from "./file-kinds.js";
+import { CODE_KINDS, detectFileKind, DOTNET_CSHARP_ROOT_MARKERS, DOTNET_FSHARP_ROOT_MARKERS, KIND_EXTENSIONS, } from "./file-kinds.js";
 import { getProjectIgnoreMatcher } from "./file-utils.js";
+import { direntsHaveMarkerGlobMatch } 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 } from "./workspace-topology.js";
-export const SUPPORTED_FILE_KINDS = [
-    "jsts",
-    "python",
-    "go",
-    "rust",
-    "cxx",
-    "cmake",
-    "fish",
-    "shell",
-    "json",
-    "markdown",
-    "css",
-    "yaml",
-    "sql",
-    "ruby",
-    "html",
-    "docker",
-    "php",
-    "powershell",
-    "prisma",
-    "csharp",
-    "fsharp",
-    "java",
-    "kotlin",
-    "swift",
-    "dart",
-    "lua",
-    "zig",
-    "haskell",
-    "elixir",
-    "gleam",
-    "ocaml",
-    "clojure",
-    "terraform",
-    "nix",
-    "toml",
-];
+/** 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"],
@@ -72,6 +38,8 @@ const PROJECT_MARKERS_BY_KIND = {
     terraform: [".terraform.lock.hcl"],
     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: [
@@ -114,7 +82,19 @@ const ROOT_MARKERS_BY_KIND = {
     terraform: [".terraform.lock.hcl"],
     nix: ["flake.nix"],
     toml: ["pyproject.toml", "Cargo.toml", "taplo.toml"],
+    csharp: DOTNET_CSHARP_ROOT_MARKERS,
+    fsharp: DOTNET_FSHARP_ROOT_MARKERS,
 };
+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;
+    }
+}
 // Process-lifetime memo keyed on projectRoot. 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
@@ -142,7 +122,7 @@ function computeProjectLanguageProfile(projectRoot, sourceFiles) {
         if (!markers)
             continue;
         for (const marker of markers) {
-            if (fs.existsSync(path.join(projectRoot, marker))) {
+            if (hasProjectMarker(projectRoot, marker)) {
                 present[kind] = true;
                 configured[kind] = true;
                 break;
@@ -240,38 +220,26 @@ export function resolveLanguageRootForFile(filePath, workspaceRoot) {
 // the tree itself), and the result is stored in the shared
 // `languageProfileCache` so the subsequent sync caller skips the walk.
 // ---------------------------------------------------------------------------
-// Extensions accepted as project source files. Mirrors the discovery rules
-// used by scan-utils.ts but inlined here to keep this file self-contained
-// and avoid pulling in source-filter's heavier dependency graph during
-// warmup.
-const WARMUP_SOURCE_EXTS = new Set([
-    ".ts",
-    ".tsx",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".py",
-    ".go",
-    ".rs",
-    ".rb",
-    ".java",
-    ".kt",
-    ".swift",
-    ".c",
-    ".cc",
-    ".cpp",
-    ".cxx",
-    ".h",
-    ".hpp",
-    ".cs",
-]);
+// 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);
@@ -280,9 +248,23 @@ export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP
     // detection. Fail-open on no-git/spawn failure.
     await ignoreMatcher.ensureTrackedIndex();
     const stack = [root];
-    const out = [];
+    // #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;
-    while (stack.length > 0) {
+    walk: while (stack.length > 0) {
         const current = stack.pop();
         if (!current)
             continue;
@@ -303,10 +285,17 @@ export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP
                 const ext = path.extname(entry.name).toLowerCase();
                 if (!WARMUP_SOURCE_EXTS.has(ext))
                     continue;
-                out.push(fullPath);
-                // Hard cap — language detection only needs presence (#250).
-                if (out.length >= maxFiles)
-                    return out;
+                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;
+                }
             }
             if (++processedSinceYield % yieldEvery === 0) {
                 // See countSourceFilesWithinLimitAsync for why setImmediate.
@@ -314,7 +303,7 @@ export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP
             }
         }
     }
-    return out;
+    return [...codeOut, ...nonCodeOut];
 }
 export async function detectProjectLanguageProfileAsync(projectRoot) {
     const cached = languageProfileCache.get(projectRoot);

package/dist/clients/latency-logger.js

@@ -1,16 +1,19 @@
-import * as fs from "node:fs";
 import * as path from "node:path";
 import { isTestMode } from "./env-utils.js";
 import { getGlobalPiLensDir } from "./file-utils.js";
 import { createNdjsonLogger } from "./ndjson-logger.js";
+import { getMaxLogSizeMB } from "./log-cleanup.js";
 const LATENCY_LOG_DIR = getGlobalPiLensDir();
 const LATENCY_LOG_FILE = path.join(LATENCY_LOG_DIR, "latency.log");
-const writer = createNdjsonLogger({ filePath: LATENCY_LOG_FILE });
+const writer = createNdjsonLogger({
+    filePath: LATENCY_LOG_FILE,
+    maxBytes: getMaxLogSizeMB() * 1024 * 1024,
+});
 export function logLatency(entry) {
     if (isTestMode()) {
         return;
     }
-    writer.log({ ts: new Date().toISOString(), ...entry });
+    writer.log({ ...entry, ts: new Date().toISOString(), pid: process.pid });
 }
 export function getLatencyLogPath() {
     return LATENCY_LOG_FILE;
@@ -19,19 +22,6 @@ export function getLatencyLogPath() {
 export function flushLatencyLog() {
     return writer.flush();
 }
-export function readLatencyLog(limit = 100) {
-    try {
-        const content = fs.readFileSync(LATENCY_LOG_FILE, "utf-8");
-        const lines = content.trim().split(/\r?\n/).filter(Boolean);
-        return lines
-            .slice(-limit)
-            .map((line) => JSON.parse(line))
-            .reverse();
-    }
-    catch {
-        return [];
-    }
-}
 export function clearLatencyLog() {
     // Enqueue the truncate in the same serialized queue so a clear cannot race a
     // pending drain. Await flushLatencyLog() if you need the file empty on disk.