pi-lens 3.8.72 → 3.8.73

package/dist/tools/lsp-diagnostics.js

@@ -11,7 +11,7 @@ import { getProjectIgnoreMatcher, isExcludedDirName, } from "../clients/file-uti
 import { getLSPService, groupFilesByPrimaryServer, runPerServerGroups, } from "../clients/lsp/index.js";
 import { buildScopeKey, createWorkspaceDiagnosticsCacheContext, } from "../clients/lsp/workspace-diagnostics-cache.js";
 import { primaryServerId } from "../clients/lsp/config.js";
-import { combineAbortSignals } from "../clients/deadline-utils.js";
+import { combineAbortSignals, withDeadline } from "../clients/deadline-utils.js";
 import { applyAuxiliarySuppressions, retagAuxiliaryDiagnostics, } from "../clients/dispatch/auxiliary-lsp.js";
 import { detectFileRole } from "../clients/file-role.js";
 import { classifyCascadeWaitTier } from "../clients/lsp/wait-policy/index.js";
@@ -59,6 +59,7 @@ const MAX_BATCH_FILES = 100;
 const MAX_DIAGNOSTICS = 200;
 const DEFAULT_BATCH_CONCURRENCY = 8;
 const MAX_BATCH_CONCURRENCY = 16;
+const DEFAULT_BATCH_FILE_DEADLINE_MS = 15_000;
 // LSP severities: 1=Error, 2=Warning, 3=Information, 4=Hint
 const SEVERITY_NAMES = {
     1: "error",
@@ -66,6 +67,10 @@ const SEVERITY_NAMES = {
     3: "information",
     4: "hint",
 };
+function batchFileDeadlineMs() {
+    const raw = Number(process.env.PI_LENS_LSP_BATCH_FILE_MS);
+    return Number.isFinite(raw) && raw > 0 ? raw : DEFAULT_BATCH_FILE_DEADLINE_MS;
+}
 // #646: `primaryServerId` moved to clients/lsp/config.ts so this tool and
 // tools/lens-diagnostics.ts's mode=full sweep share the exact same
 // primary-vs-auxiliary classification instead of each keeping its own copy.
@@ -252,6 +257,19 @@ nextWriteIndex) {
                 const suffix = timedOutFiles > 0 ? ` (${timedOutFiles} timed out)` : "";
                 return `lsp_diagnostics${scope} — ${count} ${noun} · ${cleanFiles} clean · ${unconfirmedFiles} unconfirmed${suffix}`;
             }
+            const outcomeCounts = details?.outcomeCounts;
+            const notConfirmed = outcomeCounts
+                ? (outcomeCounts.inconclusive ?? 0) +
+                    (outcomeCounts.unavailable ?? 0) +
+                    (outcomeCounts.unsupported ?? 0) +
+                    (outcomeCounts.failed ?? 0)
+                : 0;
+            if (notConfirmed > 0) {
+                return `lsp_diagnostics${scope} — ${count} ${noun} · ${notConfirmed} checks not confirmed`;
+            }
+            if ((details?.incompleteFiles ?? 0) > 0) {
+                return `lsp_diagnostics${scope} — incomplete (${details?.incompleteFiles} files not confirmed)`;
+            }
             // Single-file mode: 0 diagnostics from an unconfirmed result — either a
             // silent-on-clean server or (#570) a timed-out check — is not a clean
             // render either.
@@ -321,12 +339,29 @@ nextWriteIndex) {
                     details: {},
                 };
             }
-            if (Array.isArray(typedParams.paths) &&
-                typedParams.paths.length > 0) {
-                const absPaths = typedParams.paths
-                    .filter((entry) => typeof entry === "string" && entry.trim().length > 0)
-                    .slice(0, MAX_BATCH_FILES)
-                    .map((entry) => path.isAbsolute(entry) ? entry : path.resolve(cwd, entry));
+            if (Array.isArray(typedParams.paths) && typedParams.paths.length > 0) {
+                if (typedParams.paths.length > MAX_BATCH_FILES) {
+                    return {
+                        content: [{
+                                type: "text",
+                                text: `paths accepts at most ${MAX_BATCH_FILES} files; received ${typedParams.paths.length}.`,
+                            }],
+                        isError: true,
+                        details: { mode: "batch", filesChecked: 0 },
+                    };
+                }
+                const rawPaths = typedParams.paths.filter((entry) => typeof entry === "string" && entry.trim().length > 0);
+                if (rawPaths.length !== typedParams.paths.length) {
+                    return {
+                        content: [{ type: "text", text: "paths must contain non-empty file paths." }],
+                        isError: true,
+                        details: { mode: "batch", filesChecked: 0 },
+                    };
+                }
+                // Preserve input order (including duplicate entries); normalize each
+                // path before grouping so Windows separators and dot segments cannot
+                // change cache/group identity. Explicit lists never enter the walker.
+                const absPaths = rawPaths.map((entry) => path.normalize(path.isAbsolute(entry) ? entry : path.resolve(cwd, entry)));
                 return runBatchFileDiagnostics(absPaths, severity, lspService, {
                     concurrency,
                     waitMs,
@@ -799,6 +834,34 @@ function tallyConfirmation(results) {
     }
     return { clean, unconfirmed, timedOut };
 }
+function classifyBatchFileOutcome(result) {
+    if (result.error)
+        return "failed";
+    // A timed-out/unconfirmed answer may contain partial findings, but it cannot
+    // honestly be called a complete findings result. Keep the raw findings for
+    // investigation while making the aggregate incomplete.
+    if (result.timedOut || result.confirmation === "unconfirmed") {
+        return "inconclusive";
+    }
+    if (result.diagnostics.length > 0)
+        return "findings";
+    if (result.unavailable) {
+        return result.primaryServerId ? "unavailable" : "unsupported";
+    }
+    if (!result.primaryServerId)
+        return "unsupported";
+    return "clean";
+}
+function inconclusiveBatchResult(file, reason) {
+    return {
+        file,
+        diagnostics: [],
+        confirmation: "unconfirmed",
+        timedOut: true,
+        outcome: "inconclusive",
+        inconclusiveReason: reason,
+    };
+}
 /**
  * #570: build the explanatory clause for a batch/directory result that has
  * unconfirmed files, distinguishing timed-out checks from the pre-existing
@@ -846,7 +909,32 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
     const resolvedCwd = options.cwd ?? process.cwd();
     const cacheCtx = createWorkspaceDiagnosticsCacheContext(resolvedCwd);
     const scopeKey = buildScopeKey(options.serverScope ?? "all");
-    const results = await mapWithConcurrency(files, options.concurrency, (file) => collectFileDiagnosticResult(file, severity, lspService, options.waitMs, options.nextWriteIndex, options.serverScope, cacheCtx, scopeKey, resolvedCwd), lspService, options.signal, options.onProgress);
+    const results = await mapWithConcurrency(files, options.concurrency, async (file) => {
+        const work = collectFileDiagnosticResult(file, severity, lspService, options.waitMs, options.nextWriteIndex, options.serverScope, cacheCtx, scopeKey, resolvedCwd);
+        const bounded = withDeadline(work, {
+            ms: batchFileDeadlineMs(),
+            onTimeout: "undefined",
+            onReject: "undefined",
+        });
+        const result = options.signal
+            ? await Promise.race([
+                bounded,
+                new Promise((resolve) => {
+                    if (options.signal?.aborted) {
+                        resolve(undefined);
+                        return;
+                    }
+                    options.signal?.addEventListener("abort", () => resolve(undefined), {
+                        once: true,
+                    });
+                }),
+            ])
+            : await bounded;
+        return (result ??
+            inconclusiveBatchResult(file, options.signal?.aborted
+                ? "Batch aborted before this file completed."
+                : `File check exceeded ${batchFileDeadlineMs()}ms.`));
+    }, lspService, options.signal, options.onProgress);
     // Persist whatever was recorded, including a partial/aborted sweep's
     // already-completed files — same "don't throw away confirmed work"
     // posture as `runWorkspaceDiagnostics`.
@@ -858,6 +946,10 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
     const truncated = total > MAX_DIAGNOSTICS;
     const display = truncated ? allDiags.slice(0, MAX_DIAGNOSTICS) : allDiags;
     const { clean, unconfirmed, timedOut } = tallyConfirmation(results);
+    for (const result of results) {
+        result.outcome = classifyBatchFileOutcome(result);
+    }
+    const outcomeCounts = Object.fromEntries(["clean", "findings", "unsupported", "unavailable", "failed", "inconclusive"].map((outcome) => [outcome, results.filter((result) => result.outcome === outcome).length]));
     // Per-file primary-server lookup so a flattened multi-file `display` list
     // can still be split into "primary findings" vs "auxiliary findings" —
     // `clean`/`unconfirmed` above already reflect ONLY the primary server's
@@ -877,6 +969,8 @@ async function collectBatchDiagnostics(files, severity, lspService, options) {
         clean,
         unconfirmed,
         timedOut,
+        outcomeCounts,
+        incompleteFiles: Math.max(0, files.length - results.length),
     };
 }
 async function runBatchFileDiagnostics(absPaths, severity, lspService, options) {
@@ -887,7 +981,7 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
             details: { mode: "batch", severity, filesChecked: 0 },
         };
     }
-    const { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, timedOut, } = await collectBatchDiagnostics(absPaths, severity, lspService, options);
+    const { results, fileErrors, lspHealthWarnings, total, truncated, display, primaryDisplay, auxiliaryDisplay, clean, unconfirmed, timedOut, outcomeCounts, incompleteFiles, } = await collectBatchDiagnostics(absPaths, severity, lspService, options);
     const lines = [
         `Files checked: ${results.length}`,
         `Total diagnostics: ${total}`,
@@ -895,6 +989,20 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
     ];
     if (options.waitMs !== undefined)
         lines.push(`Wait budget: ${options.waitMs}ms`);
+    lines.push(`Outcomes: ${Object.entries(outcomeCounts)
+        .map(([outcome, count]) => `${outcome}=${count}`)
+        .join(", ")}`);
+    const notConfirmed = outcomeCounts.inconclusive +
+        outcomeCounts.unavailable +
+        outcomeCounts.unsupported +
+        outcomeCounts.failed +
+        incompleteFiles;
+    if (notConfirmed > 0) {
+        lines.push("", `Checks not confirmed: ${notConfirmed} (inconclusive/unavailable/unsupported/failed or not started).`);
+    }
+    if (incompleteFiles > 0) {
+        lines.push("", `Batch incomplete: ${incompleteFiles} file${incompleteFiles === 1 ? "" : "s"} were not confirmed because the batch was aborted.`);
+    }
     if (fileErrors.length > 0)
         lines.push("", "File errors:", ...fileErrors);
     if (lspHealthWarnings.length > 0) {
@@ -945,6 +1053,15 @@ async function runBatchFileDiagnostics(absPaths, severity, lspService, options)
             cleanFiles: clean,
             unconfirmedFiles: unconfirmed,
             timedOutFiles: timedOut > 0 ? timedOut : undefined,
+            outcomes: results.map((result) => ({
+                file: result.file,
+                outcome: result.outcome,
+                reason: result.inconclusiveReason ?? result.error ?? result.unavailable,
+                primaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.source === result.primaryServerId).length,
+                auxiliaryDiagnosticsCount: result.diagnostics.filter((diagnostic) => diagnostic.source !== result.primaryServerId).length,
+            })),
+            outcomeCounts,
+            incompleteFiles: incompleteFiles > 0 ? incompleteFiles : undefined,
             fileErrors: fileErrors.length > 0 ? fileErrors : undefined,
             lspHealthWarnings: lspHealthWarnings.length > 0 ? lspHealthWarnings : undefined,
         },

package/docs/servercapabilities.md

@@ -6,7 +6,7 @@ server's `initialize` handshake. Generated by `node scripts/server-capabilities.
 absent on the generating host are listed under *Unavailable* — run in a
 provisioned environment (the nightly) to capture those rows.
 
-_Last generated: 2026-07-26 on linux; 30 servers captured, 11 unavailable._
+_Last generated: 2026-07-28 on linux; 30 servers captured, 11 unavailable._
 
 ## Diagnostic mode + navigation/edit operations
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "3.8.72",
+	"version": "3.8.73",
 	"type": "module",
 	"description": "Real-time code feedback for pi — LSP, linters, formatters, type-checking, structural analysis & booboo",
 	"repository": {
@@ -14,7 +14,7 @@
 	},
 	"scripts": {
 		"build": "tsc --project tsconfig.build.json",
-		"build:dist": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && npx --yes -p typescript@6 tsc --project tsconfig.dist.json --noCheck && npm run bundle:dist",
+		"build:dist": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\" && npx --yes -p typescript@7.0.2 tsc --project tsconfig.dist.json --noCheck && npm run bundle:dist",
 		"bundle:dist": "node scripts/bundle-dist.mjs",
 		"prepare": "npm run build:dist && node scripts/download-grammars.js --core --dest grammars",
 		"lint": "tsc --project tsconfig.json",
@@ -82,10 +82,10 @@
 		"banner.png"
 	],
 	"dependencies": {
-		"@ast-grep/cli": "^0.44.0",
-		"@ast-grep/napi": "^0.44.0",
-		"@earendil-works/pi-tui": "^0.80.2",
-		"js-yaml": "^4.1.1",
+		"@ast-grep/cli": "^0.45.0",
+		"@ast-grep/napi": "^0.45.0",
+		"@earendil-works/pi-tui": "^0.82.1",
+		"js-yaml": "^5.2.2",
 		"minimatch": "^10.2.5",
 		"pidusage": "^4.0.1",
 		"typebox": "^1.0.0",
@@ -104,12 +104,11 @@
 	},
 	"devDependencies": {
 		"@biomejs/biome": "^2.4.10",
-		"@earendil-works/pi-coding-agent": "^0.80.2",
-		"@types/js-yaml": "^4.0.9",
+		"@earendil-works/pi-coding-agent": "^0.82.1",
 		"@types/node": "^26.0.0",
 		"@types/pidusage": "^2.0.5",
 		"@vitest/coverage-v8": "^4.1.5",
-		"typescript": "^6.0.3",
+		"typescript": "^7.0.2",
 		"typescript-language-server": "^5.1.3",
 		"vitest": "^4.1.1"
 	},

package/rules/tree-sitter-queries/typescript/no-equality-in-for-condition.yml

@@ -4,6 +4,7 @@ id: no-equality-in-for-condition
 name: Loose equality in for-loop condition
 severity: warning
 category: bug
+defect_class: correctness
 inline_tier: warning
 language: typescript
 

package/rules/tree-sitter-queries/typescript/no-jump-in-finally.yml

@@ -4,6 +4,7 @@ id: no-jump-in-finally
 name: Control-flow jump in finally block
 severity: warning
 category: bug
+defect_class: silent-error
 inline_tier: warning
 language: typescript