pi-lens 4.2.0 → 4.2.1

package/dist/tools/lens-diagnostic-mark.js

@@ -45,8 +45,9 @@ import * as path from "node:path";
 import { Type } from "../clients/deps/typebox.js";
 import { markDisposition, normalizeMessage, } from "../clients/diagnostic-dispositions.js";
 import { insertSuppressComment } from "../clients/dispatch/suppress-writer.js";
-import { getFileDiagnostics, } from "../clients/widget-state.js";
+import { normalizeMapKey } from "../clients/path-utils.js";
 import { resolveLensToolName } from "../clients/tool-config.js";
+import { getFileDiagnostics, } from "../clients/widget-state.js";
 const DISPOSITIONS = [
     "false-positive",
     "suppress",
@@ -70,11 +71,22 @@ function isBlank(text) {
  * violation) are ambiguous; per #802 this picks the match CLOSEST to the
  * caller's line rather than guessing — the conservative choice for suppress,
  * which must never place a comment above the wrong site.
+ *
+ * #3160: `getFileDiagnostics` keys with `normalizeEphemeralMapKey` — case-
+ * preserving on POSIX by design (no filesystem I/O on that hot path) — but
+ * the widget's own writers key from `ctx.filePath`, which
+ * `createDispatchContext` already canonicalizes to the on-disk casing
+ * (#2016/#3098). `absPath` here is the caller's RAW spelling, so on a
+ * case-insensitive filesystem a mis-cased mark call must derive the same
+ * canonical key the writers used or it silently misses the live diagnostic
+ * and falls through to the fuzzy fallback below — do NOT case-fold
+ * `normalizeEphemeralMapKey` itself for this: on a case-sensitive filesystem
+ * that would merge two genuinely different files.
  */
 function widgetCrossCheck(absPath, tool, rule, message, callerLine) {
     let diagnostics;
     try {
-        diagnostics = getFileDiagnostics(absPath);
+        diagnostics = getFileDiagnostics(normalizeMapKey(absPath));
     }
     catch {
         return undefined;

package/dist/tools/lens-diagnostics.js

@@ -18,13 +18,13 @@ import { DEPENDENCY_DRIFT_MAX_DELIVERIES } from "../clients/blocker-freshness.js
 import { freshnessFromMtime } from "../clients/freshness.js";
 import { applyFindingPolicy, loadProjectRulePolicyMap, } from "../clients/dispatch/finding-policy.js";
 import { gateFindingsByPathFreshness } from "../clients/advisory-provenance.js";
-import { markUnreconciledFindings } from "../clients/finding-delivery-gate.js";
+import { formatCacheAgeLabel, markUnreconciledFindings, } from "../clients/finding-delivery-gate.js";
 import { normalizeRuleId } from "../clients/dispatch/rule-id-normalize.js";
 import { applyRulePolicy, } from "../clients/dispatch/rule-policy.js";
 import { compactRenderResult } from "./render-compact.js";
 import { combineAbortSignals } from "../clients/deadline-utils.js";
 import { getProjectIgnoreMatcher } from "../clients/file-utils.js";
-import { isAtOrAboveHomeDir, normalizeEphemeralMapKey, normalizeFilePath, realpathOrResolve, } from "../clients/path-utils.js";
+import { isAtOrAboveHomeDir, normalizeEphemeralMapKey, normalizeFilePath, normalizeMapKey, realpathOrResolve, } from "../clients/path-utils.js";
 import { getLSPService } from "../clients/lsp/index.js";
 import { retireInlineBlockerAndResyncGuard } from "../clients/git-guard.js";
 import { primaryServerId, resolveLspCwdForFile, } from "../clients/lsp/config.js";
@@ -508,7 +508,7 @@ function formatProjectDeltaDiagnostic(diagnostic, stale) {
  * rule/message), live -> unchanged. See `clients/finding-delivery-gate.ts`
  * surface `lens-diagnostics:mode-delta`.
  */
-function appendProjectDiagnosticsDeltaLines(lines, cwd, report, severity, includeFile) {
+function appendProjectDiagnosticsDeltaLines(groups, cwd, report, severity, includeFile) {
     const scoped = (report?.diagnostics ?? []).filter((diagnostic) => includeFile(diagnostic.filePath) &&
         matchesSeverity(projectDiagnosticToWidget(diagnostic, diagnostic.filePath), severity));
     const gated = gateFindingsByPathFreshness({
@@ -532,11 +532,9 @@ function appendProjectDiagnosticsDeltaLines(lines, cwd, report, severity, includ
         byFile.set(filePath, bucket);
     }
     for (const [filePath, fileDiagnostics] of byFile) {
-        const rel = path.relative(cwd, filePath);
-        if (!lines.includes(rel))
-            lines.push(rel);
+        const group = getDeltaFileGroup(groups, cwd, filePath);
         for (const diagnostic of fileDiagnostics) {
-            lines.push(formatProjectDeltaDiagnostic(diagnostic, staleSet.has(diagnostic)));
+            group.projectLines.push(formatProjectDeltaDiagnostic(diagnostic, staleSet.has(diagnostic)));
         }
     }
     return diagnostics.length;
@@ -723,7 +721,15 @@ function applyDeltaFreshnessGate(files, cwd, generatedAt) {
     }
     for (const f of gated.stale) {
         const arr = byFile.get(f.filePath) ?? [];
-        arr.push({ ...f.warning, stale: true, line: undefined });
+        // Fix B (#3167): carry the stamp the row was judged against so the render
+        // can emit one age label per file group — the row's own observation stamp,
+        // not the report-level one (the #2504 r4 multi-stamp case).
+        arr.push({
+            ...f.warning,
+            stale: true,
+            line: undefined,
+            staleAsOf: effectiveAt,
+        });
         byFile.set(f.filePath, arr);
     }
     return files
@@ -733,10 +739,34 @@ function applyDeltaFreshnessGate(files, cwd, generatedAt) {
     }))
         .filter((file) => file.warnings.length > 0);
 }
+function getDeltaFileGroup(groups, cwd, filePath) {
+    const rel = path.relative(cwd, filePath);
+    let group = groups.get(rel);
+    if (!group) {
+        group = {
+            rel,
+            actionableLines: [],
+            qualityLines: [],
+            projectLines: [],
+            incomplete: false,
+        };
+        groups.set(rel, group);
+    }
+    return group;
+}
 // @delivery-surface: lens-diagnostics:mode-delta
 function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
     const actionableEntry = cacheManager.readCache("actionable-warnings", cwd);
     const qualityEntry = cacheManager.readCache("code-quality-warnings", cwd);
+    // #3170: files whose re-verify pass could not complete inside its budget —
+    // their rows render as carried, plus this explicit gap label (never a
+    // false clean). Computed from the RAW actionable-warnings cache entries
+    // because the freshness pipeline below rebuilds the file shape. The
+    // re-verify only ever writes the actionable-warnings cache — the quality
+    // report's file shape carries no such marker.
+    const reverifyIncompletePaths = new Set((actionableEntry?.data?.files ?? [])
+        .filter((file) => file.reVerifyIncomplete)
+        .map((file) => normalizeMapKey(file.filePath)));
     const actionable = actionableEntry?.data;
     const quality = qualityEntry?.data;
     // Project rule policy (`.pi-lens.json` `rules.<id>.disable` /
@@ -778,32 +808,69 @@ function formatDeltaMode(cacheManager, cwd, severity, pathsScope) {
         warnings: matchingWarnings(file.warnings),
     }))
         .filter((file) => file.warnings.length > 0);
-    const lines = [];
+    // #3196: one grouping pass keyed by file — every tier below appends into
+    // the SAME per-file group (see `DeltaFileGroup`/`getDeltaFileGroup`), so a
+    // file present in more than one report always renders its rows under its
+    // own header, wherever that header ends up in the final buffer.
+    const groups = new Map();
     // Fixable warnings from actionable-warnings and quality cache entries retain
     // their own severity tier. Apply the same threshold semantics as the LSP path.
+    // F5/F10 (#3168): at most ONE label group (age and/or #3170's re-verify
+    // gap) per file. The actionable tier is folded first, so its stale row (if
+    // any) wins the group's age label; the quality tier only supplies one when
+    // the actionable tier had none for that file (#3168 F10(c)'s quality-only
+    // shape). The `(re-verify incomplete)` flag is a fact about the file (from
+    // the raw actionable cache, independent of which tier's rows happen to
+    // render it), so it is recorded on the group the first time either tier
+    // touches that file and never predicted.
     if (filteredActionableFiles.length > 0) {
         for (const file of filteredActionableFiles) {
-            const rel = path.relative(cwd, file.filePath);
-            lines.push(`${rel}`);
+            const group = getDeltaFileGroup(groups, cwd, file.filePath);
             for (const w of file.warnings) {
                 const where = w.stale ? STALE_LINE_MARKER : `L${w.line ?? "?"}`;
-                lines.push(`  ⚠ ${where}  ${w.rule ?? w.code ?? w.tool}  ${w.message}`);
+                group.actionableLines.push(`  ⚠ ${where}  ${w.rule ?? w.code ?? w.tool}  ${w.message}`);
+            }
+            const key = normalizeMapKey(file.filePath);
+            if (reverifyIncompletePaths.has(key))
+                group.incomplete = true;
+            if (!group.staleRow) {
+                const staleWarning = file.warnings.find((w) => w.stale);
+                if (staleWarning)
+                    group.staleRow = { staleAsOf: staleWarning.staleAsOf };
             }
         }
     }
     // Quality issues
     if (filteredQualityFiles.length > 0) {
         for (const file of filteredQualityFiles) {
-            const rel = path.relative(cwd, file.filePath);
-            if (!lines.includes(rel))
-                lines.push(rel);
+            const group = getDeltaFileGroup(groups, cwd, file.filePath);
             for (const w of file.warnings) {
                 const where = w.stale ? STALE_LINE_MARKER : `L${w.line ?? "?"}`;
-                lines.push(`  ℹ ${where}  ${w.rule ?? w.code ?? w.tool}  ${w.message}`);
+                group.qualityLines.push(`  ℹ ${where}  ${w.rule ?? w.code ?? w.tool}  ${w.message}`);
+            }
+            const key = normalizeMapKey(file.filePath);
+            if (reverifyIncompletePaths.has(key))
+                group.incomplete = true;
+            if (!group.staleRow) {
+                const staleWarning = file.warnings.find((w) => w.stale);
+                if (staleWarning)
+                    group.staleRow = { staleAsOf: staleWarning.staleAsOf };
             }
         }
     }
-    const projectDeltaCount = appendProjectDiagnosticsDeltaLines(lines, cwd, projectDelta, severity, includeFile);
+    const projectDeltaCount = appendProjectDiagnosticsDeltaLines(groups, cwd, projectDelta, severity, includeFile);
+    const lines = [];
+    for (const group of groups.values()) {
+        lines.push(group.rel);
+        lines.push(...group.actionableLines);
+        lines.push(...group.qualityLines);
+        lines.push(...group.projectLines);
+        if (group.staleRow) {
+            lines.push(`  (${formatCacheAgeLabel(group.staleRow.staleAsOf)})`);
+        }
+        if (group.incomplete)
+            lines.push("  (re-verify incomplete)");
+    }
     const selectedActionableFiles = filteredActionableFiles;
     const selectedQualityFiles = filteredQualityFiles;
     const aw = selectedActionableFiles.reduce((count, file) => count + file.warnings.length, 0);

package/dist/tools/lsp-diagnostics.js

@@ -23,7 +23,8 @@ import { classifyCascadeWaitTier } from "../clients/lsp/wait-policy/index.js";
 import { attemptTsserverSyncDiagnostics } from "../clients/lsp/tsserver-sync.js";
 import { convertLspDiagnostics } from "../clients/dispatch/utils/lsp-diagnostics.js";
 import { demoteInferredProjectDiagnostics } from "../clients/lsp/inferred-project.js";
-import { isBlocking, reconcileScanDiagnostics, } from "../clients/widget-state.js";
+import { normalizeMapKey } from "../clients/path-utils.js";
+import { countRetainedSuppressedRows, isBlocking, reconcileScanDiagnostics, } from "../clients/widget-state.js";
 import { makeProgressReporter } from "./scan-progress.js";
 import { isWarmAttached, tryWarmAttachedDiagnostics, } from "../clients/warm-attach.js";
 import { extensionsForLanguage, SCAN_LANGUAGE_PRIORITY, } from "../clients/language-registry.js";
@@ -239,7 +240,18 @@ onConfirmedNoBlockers, getService = getLSPService) {
                 // 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)));
+                // #3160/#3182: `path.resolve(cwd, entry)` folds dot segments (and
+                // separators) structurally — it ignores `cwd` whenever `entry` is
+                // already absolute, so the old `path.isAbsolute` ternary is
+                // redundant. `normalizeMapKey` then adopts on-disk CASING where the
+                // path exists — an agent-typed, possibly mis-cased `paths` entry
+                // must key `reconcileScanDiagnostics`'s widget-state write the same
+                // way a canonical writer (clients/pipeline.ts's ctx.filePath) or the
+                // #3160-fixed lens_diagnostic_mark reader would. `path.resolve`
+                // stays required for the relative→absolute step: `normalizeMapKey`
+                // folds dot segments itself since #3184, but never resolves against
+                // `cwd` (a cwd fold there broke every monorepo, #2490).
+                const absPaths = rawPaths.map((entry) => normalizeMapKey(path.resolve(cwd, entry)));
                 return runBatchFileDiagnostics(absPaths, severity, lspService, {
                     concurrency,
                     waitMs,
@@ -264,9 +276,12 @@ onConfirmedNoBlockers, getService = getLSPService) {
                     details: {},
                 };
             }
-            const absPath = path.isAbsolute(rawPath)
-                ? rawPath
-                : path.resolve(cwd, rawPath);
+            // #3184: the single-`path` sibling of the `paths` batch above, and
+            // keyed the same way — `runFileDiagnostics` hands this straight to
+            // `reconcileScanDiagnostics`, whose `normalizeEphemeralMapKey` key
+            // derivation folds neither dot segments nor casing. Same expression as
+            // :444 so both modes of this tool write under ONE key per file.
+            const absPath = normalizeMapKey(path.resolve(cwd, rawPath));
             let stat;
             try {
                 stat = fs.statSync(absPath);
@@ -616,6 +631,17 @@ severity) {
             // otherwise have SEEN, never one per finding (AGENTS.md "bounded
             // observability"). `total` is the in-scope population for the same
             // reason the count is, so the record and the rendered line agree.
+            //
+            // #3158 round 2 F4: `retainedSuppressed` is the widget store's
+            // SUCCESS-path number — how many suppressed rows the store is carrying
+            // INTO this scan, written by the scans before it. Until this, retention
+            // was observable only when its per-file cap truncated
+            // (`widget-suppressed-retention-capped`), so a healthy footer chip had no
+            // record behind it at all. Folded into the record this lane already emits
+            // rather than added as a second one: same cardinality (one per filtered
+            // file per scan, never one per row), no new sink, and the two numbers are
+            // read together — `suppressed` is what THIS scan dropped,
+            // `retainedSuppressed` is what the footer chip is still counting.
             logLatency({
                 type: "phase",
                 toolName: "lsp_diagnostics",
@@ -625,6 +651,7 @@ severity) {
                 metadata: {
                     suppressed,
                     total: inScopeBefore,
+                    retainedSuppressed: countRetainedSuppressedRows(file),
                 },
             });
         }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "pi-lens",
-	"version": "4.2.0",
+	"version": "4.2.1",
 	"type": "module",
 	"description": "Real-time code feedback for pi — LSP, linters, formatters, type-checking, structural analysis & booboo",
 	"repository": {