pi-lens 3.8.71 → 3.8.72

package/dist/clients/lens-config.js

@@ -1,18 +1,38 @@
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { parseEnabledShape } from "./config-enabled-shape.js";
+import { findNestedProjectMutationValue, } from "./project-lens-config.js";
 export function getPiLensGlobalConfigPath(homeDir = os.homedir()) {
     const override = process.env.PI_LENS_CONFIG_PATH;
     if (override)
         return path.resolve(override);
     return path.join(homeDir, ".pi-lens", "config.json");
 }
+const warnedInvalidGlobalConfigs = new Set();
+/**
+ * Same warn-once-per-(path, reason) contract as project-lens-config.ts's
+ * `warnInvalidConfigOnce` — a malformed global config value is logged once
+ * and then treated as absent, rather than silently dropped (#792).
+ */
+function warnInvalidGlobalConfigOnce(configPath, reason) {
+    const key = `${configPath}:${reason}`;
+    if (warnedInvalidGlobalConfigs.has(key))
+        return;
+    warnedInvalidGlobalConfigs.add(key);
+    console.error(`[pi-lens] ignoring invalid global config ${configPath}: ${reason}`);
+}
+/** For tests that need to force the warn-once cache to reset between cases. */
+export function resetGlobalConfigWarnCache() {
+    warnedInvalidGlobalConfigs.clear();
+}
 export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath()) {
     try {
         const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
         if (!parsed || typeof parsed !== "object")
             return undefined;
         const raw = parsed;
+        const warnInvalid = (reason) => warnInvalidGlobalConfigOnce(configPath, reason);
         const dispatchRaw = raw.dispatch;
         const dispatch = dispatchRaw && typeof dispatchRaw === "object"
             ? dispatchRaw
@@ -21,19 +41,17 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
         const widget = widgetRaw && typeof widgetRaw === "object"
             ? widgetRaw
             : undefined;
-        const formatRaw = raw.format;
-        const format = formatRaw && typeof formatRaw === "object"
-            ? formatRaw
+        const format = parseEnabledShape(raw.format, "format", warnInvalid);
+        const autofix = parseEnabledShape(raw.autofix, "autofix", warnInvalid);
+        const formatModeRaw = raw.format;
+        const formatModeSource = formatModeRaw && typeof formatModeRaw === "object"
+            ? formatModeRaw
             : undefined;
         const actionableWarningsRaw = raw.actionableWarnings;
         const actionableWarnings = actionableWarningsRaw && typeof actionableWarningsRaw === "object"
             ? actionableWarningsRaw
             : undefined;
-        const actionableWarningsAutoFixRaw = actionableWarnings?.autoFix;
-        const actionableWarningsAutoFix = actionableWarningsAutoFixRaw &&
-            typeof actionableWarningsAutoFixRaw === "object"
-            ? actionableWarningsAutoFixRaw
-            : undefined;
+        const actionableWarningsAutoFix = parseEnabledShape(actionableWarnings?.autoFix, "actionableWarnings.autoFix", warnInvalid);
         const contextInjectionRaw = raw.contextInjection;
         const contextInjection = contextInjectionRaw && typeof contextInjectionRaw === "object"
             ? contextInjectionRaw
@@ -42,8 +60,9 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
         const turnSummary = turnSummaryRaw && typeof turnSummaryRaw === "object"
             ? turnSummaryRaw
             : undefined;
-        const formatMode = format?.mode === "immediate" || format?.mode === "deferred"
-            ? format.mode
+        const formatMode = formatModeSource?.mode === "immediate" ||
+            formatModeSource?.mode === "deferred"
+            ? formatModeSource.mode
             : undefined;
         const ignore = Array.isArray(raw.ignore)
             ? raw.ignore.filter((p) => typeof p === "string")
@@ -66,10 +85,11 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
                 : undefined,
             format: format
                 ? {
-                    enabled: typeof format.enabled === "boolean" ? format.enabled : undefined,
+                    enabled: format.enabled,
                     mode: formatMode,
                 }
                 : undefined,
+            autofix: autofix ? { enabled: autofix.enabled } : undefined,
             actionableWarnings: actionableWarnings
                 ? {
                     enabled: typeof actionableWarnings.enabled === "boolean"
@@ -82,11 +102,7 @@ export function loadPiLensGlobalConfig(configPath = getPiLensGlobalConfigPath())
                         ? actionableWarnings.deltaOnly
                         : undefined,
                     autoFix: actionableWarningsAutoFix
-                        ? {
-                            enabled: typeof actionableWarningsAutoFix.enabled === "boolean"
-                                ? actionableWarningsAutoFix.enabled
-                                : undefined,
-                        }
+                        ? { enabled: actionableWarningsAutoFix.enabled }
                         : undefined,
                 }
                 : undefined,
@@ -119,6 +135,9 @@ export function getGlobalWidgetDefaultVisible(configPath) {
 export function getGlobalAutoformatEnabled(configPath) {
     return loadPiLensGlobalConfig(configPath)?.format?.enabled !== false;
 }
+export function getGlobalAutofixEnabled(configPath) {
+    return loadPiLensGlobalConfig(configPath)?.autofix?.enabled !== false;
+}
 export function getGlobalImmediateFormatDefault(configPath) {
     return loadPiLensGlobalConfig(configPath)?.format?.mode === "immediate";
 }
@@ -128,32 +147,92 @@ export function getGlobalContextInjectionEnabled(configPath) {
 export function getGlobalTurnSummaryEnabled(configPath) {
     return loadPiLensGlobalConfig(configPath)?.turnSummary?.enabled === true;
 }
-export function resolvePiLensFlag(name, value, config) {
+/**
+ * Resolve a flag AND report which config tier decided it — same precedence
+ * as {@link resolvePiLensFlag} (which now delegates here), just also
+ * returning the `source` so callers can log e.g.
+ * "(--no-autofix, source=project)" instead of a bare boolean (#792).
+ *
+ * Precedence (unchanged, maintainer decision — project wins over global,
+ * including re-enabling; only an explicit CLI disabling flag outranks
+ * project config): cli → project → global → default.
+ */
+export function resolvePiLensFlagWithSource(name, value, config, projectConfig, editedFilePath, projectRoot) {
     if (value)
-        return value;
+        return { value, source: "cli" };
+    const mutationFlag = name === "no-autoformat" ||
+        name === "no-autofix" ||
+        name === "lens-actionable-warning-autofix"
+        ? name
+        : undefined;
+    const nested = mutationFlag && editedFilePath && projectRoot
+        ? findNestedProjectMutationValue(mutationFlag, editedFilePath, projectRoot)
+        : undefined;
+    const nestedSource = nested
+        ? path.resolve(nested.dir) === path.resolve(projectRoot)
+            ? "project"
+            : `nested-project:${nested.dir}`
+        : undefined;
     if (name === "no-autoformat") {
-        return config?.format?.enabled === false;
+        if (nested)
+            return { value: !nested.value, source: nestedSource };
+        if (projectConfig?.format?.enabled !== undefined) {
+            return { value: !projectConfig.format.enabled, source: "project" };
+        }
+        if (config?.format?.enabled === false) {
+            return { value: true, source: "global" };
+        }
+        return { value: false, source: "default" };
+    }
+    if (name === "no-autofix") {
+        if (nested)
+            return { value: !nested.value, source: nestedSource };
+        if (projectConfig?.autofix?.enabled !== undefined) {
+            return { value: !projectConfig.autofix.enabled, source: "project" };
+        }
+        if (config?.autofix?.enabled === false) {
+            return { value: true, source: "global" };
+        }
+        return { value: false, source: "default" };
     }
     if (name === "immediate-format") {
-        return config?.format?.mode === "immediate";
+        const immediate = config?.format?.mode === "immediate";
+        return { value: immediate, source: immediate ? "global" : "default" };
     }
     if (name === "lens-actionable-warnings") {
-        return config?.actionableWarnings?.enabled === true;
+        const enabled = config?.actionableWarnings?.enabled === true;
+        return { value: enabled, source: enabled ? "global" : "default" };
     }
     if (name === "lens-actionable-warning-actions") {
-        return config?.actionableWarnings?.includeLspCodeActions === true;
+        const enabled = config?.actionableWarnings?.includeLspCodeActions === true;
+        return { value: enabled, source: enabled ? "global" : "default" };
     }
     if (name === "lens-actionable-warning-autofix") {
-        return config?.actionableWarnings?.autoFix?.enabled === true;
+        if (nested)
+            return { value: nested.value, source: nestedSource };
+        if (projectConfig?.actionableWarnings?.autoFix?.enabled !== undefined) {
+            return {
+                value: projectConfig.actionableWarnings.autoFix.enabled,
+                source: "project",
+            };
+        }
+        const enabled = config?.actionableWarnings?.autoFix?.enabled === true;
+        return { value: enabled, source: enabled ? "global" : "default" };
     }
     if (name === "lens-actionable-warning-all") {
-        return config?.actionableWarnings?.deltaOnly === false;
+        const all = config?.actionableWarnings?.deltaOnly === false;
+        return { value: all, source: all ? "global" : "default" };
     }
     if (name === "no-lens-context") {
-        return config?.contextInjection?.enabled === false;
+        const disabled = config?.contextInjection?.enabled === false;
+        return { value: disabled, source: disabled ? "global" : "default" };
     }
     if (name === "lens-turn-summary") {
-        return config?.turnSummary?.enabled === true;
+        const enabled = config?.turnSummary?.enabled === true;
+        return { value: enabled, source: enabled ? "global" : "default" };
     }
-    return value;
+    return { value, source: "default" };
+}
+export function resolvePiLensFlag(name, value, config, projectConfig, editedFilePath, projectRoot) {
+    return resolvePiLensFlagWithSource(name, value, config, projectConfig, editedFilePath, projectRoot).value;
 }

package/dist/clients/lens-engine.js

@@ -21,6 +21,7 @@ import { getLSPService } from "./lsp/index.js";
 import { getOrLoadWarmWordIndex } from "./mcp/analyze.js";
 import { scanProjectDiagnostics } from "./project-diagnostics/scanner.js";
 import * as path from "node:path";
+import { minimatch } from "./deps/minimatch.js";
 import { normalizeMapKey } from "./path-utils.js";
 import { loadProjectSnapshot } from "./project-snapshot.js";
 import { centralityFromReverseDeps, deserializeWordIndex, searchWordIndex, triggerBackgroundWordIndexBuild, } from "./word-index.js";
@@ -31,6 +32,7 @@ export { ipcPathForCwd, requestWarmAnalyze, } from "./mcp/ipc.js";
 export { analyzeFileFresh, resolveRebuildScript, runRebuild, summarizeScan, } from "./mcp/review.js";
 export { runSessionStart, runTurnEnd, } from "./mcp/session.js";
 export { moduleReport, readEnclosing, readSymbol, renderCompactModuleReport, } from "./module-report.js";
+export { projectReport, renderCompactProjectReport, } from "./project-report.js";
 // --- Query wrappers (own the remaining internal reach-ins) -------------------
 /** Recent dispatch latency reports (latency.log schema), newest first. */
 export function recentLatency(limit = 5, fileFilter) {
@@ -45,6 +47,19 @@ export function recentLatency(limit = 5, fileFilter) {
 export function projectScan(cwd, maxFiles) {
     return scanProjectDiagnostics({ cwd, tier: "cheap", maxFiles });
 }
+/**
+ * #784: `scanTruncated` (#760) reaches this seam intact but, until now, no
+ * caller rendered it — a capped scan read as a complete clean sweep to the
+ * agent/user. One shared, unit-testable line adapters can append to their
+ * rendered summary, matching the #777 warm-skip notify's override-hint style.
+ * Returns `undefined` when the scan was not truncated (no line to append).
+ */
+export function scanTruncationNotice(snapshot) {
+    if (!snapshot.scanTruncated)
+        return undefined;
+    return (`⚠ Scan truncated at ${snapshot.filesScanned} file(s) — results are partial; ` +
+        "raise maxProjectFiles in .pi-lens.json to scan fully.");
+}
 /** Alive LSP client count + per-server status. */
 export function lspStatus() {
     const lsp = getLSPService();
@@ -69,6 +84,97 @@ export function ensureLspConfig(cwd) {
 export function resourceFootprint() {
     return getResourceFootprintSnapshot();
 }
+// Same language identifiers ast_grep_search's `lang` param accepts
+// (tools/shared.ts's LANGUAGES) mapped to source file extensions. Duplicated
+// here rather than imported — clients/ never reaches into tools/ (see
+// AGENTS.md's MCP-mirror layering note) — so this is symbol_search's own small
+// copy, scoped to what its `lang` filter needs (extension matching only, no
+// AST/LSP concerns).
+const SYMBOL_SEARCH_LANG_EXTENSIONS = {
+    bash: [".sh", ".bash"],
+    c: [".c", ".h"],
+    cpp: [".cpp", ".cc", ".cxx", ".hpp", ".hh", ".hxx"],
+    csharp: [".cs"],
+    css: [".css", ".scss", ".less"],
+    elixir: [".ex", ".exs"],
+    go: [".go"],
+    haskell: [".hs", ".lhs"],
+    html: [".html", ".htm"],
+    java: [".java"],
+    javascript: [".js", ".jsx", ".mjs", ".cjs"],
+    json: [".json", ".jsonc", ".json5"],
+    kotlin: [".kt", ".kts"],
+    lua: [".lua"],
+    nix: [".nix"],
+    php: [".php"],
+    python: [".py", ".pyi"],
+    ruby: [".rb", ".rake", ".gemspec"],
+    rust: [".rs"],
+    scala: [".scala", ".sc"],
+    solidity: [".sol"],
+    swift: [".swift"],
+    tsx: [".tsx"],
+    typescript: [".ts", ".mts", ".cts"],
+    yaml: [".yaml", ".yml"],
+};
+function fileMatchesLang(file, lang) {
+    const exts = SYMBOL_SEARCH_LANG_EXTENSIONS[lang];
+    if (!exts)
+        return false;
+    return exts.includes(path.extname(file).toLowerCase());
+}
+/** Same glob semantics as ast_grep_search's `paths`: a bare directory/file
+ * entry scopes its whole subtree (via a `/**` suffix match), a full glob
+ * pattern is matched as-is. Matched relative to `cwd` so absolute index paths
+ * and repo-relative globs line up regardless of platform path separators. */
+function fileMatchesPathGlobs(file, cwd, globs) {
+    const rel = path.relative(cwd, file).split(path.sep).join("/");
+    const options = { dot: true, nocase: process.platform === "win32" };
+    return globs.some((raw) => {
+        const pattern = raw.split("\\").join("/");
+        return (minimatch(rel, pattern, options) ||
+            minimatch(rel, `${pattern}/**`, options));
+    });
+}
+function buildSymbolSearchFileFilter(cwd, options) {
+    const paths = options.paths?.filter((p) => p.trim().length > 0);
+    const lang = options.lang?.trim();
+    if (!paths?.length && !lang)
+        return undefined;
+    return (file) => {
+        if (paths?.length && !fileMatchesPathGlobs(file, cwd, paths))
+            return false;
+        if (lang && !fileMatchesLang(file, lang))
+            return false;
+        return true;
+    };
+}
+/**
+ * Attaches read-only graph signals to already-ranked hits (#771) — mutates
+ * each hit in place. `fanIn` reuses the SAME `centrality` map `symbolSearch`
+ * already computed for its ranking boost (zero extra cost); `complexity` is
+ * the highest per-symbol `cyclomaticComplexity` the (warm) review graph
+ * recorded for that file. Caller only invokes this when `graph` is defined —
+ * never builds one itself.
+ */
+function annotateSymbolSearchHitsWithGraph(hits, centrality, graph) {
+    for (const hit of hits) {
+        const normalized = normalizeMapKey(path.resolve(hit.file));
+        const fanIn = centrality.get(hit.file) ?? 0;
+        let complexity;
+        for (const symbolId of graph.symbolNodesByFile.get(normalized) ?? []) {
+            const raw = graph.nodes.get(symbolId)?.metadata?.cyclomaticComplexity;
+            if (typeof raw === "number" &&
+                (complexity === undefined || raw > complexity)) {
+                complexity = raw;
+            }
+        }
+        hit.annotations = {
+            fanIn,
+            ...(complexity !== undefined ? { complexity } : {}),
+        };
+    }
+}
 function toSymbolSearchHit(result) {
     const line = result.lines[0] ?? 1;
     return {
@@ -98,8 +204,22 @@ function toSymbolSearchHit(result) {
  * pilens_analyze yet this process, or #348 phase 2's forward-index isn't
  * available) — this function's public contract (available/hint/results shape)
  * is unchanged either way.
+ *
+ * `options.paths`/`options.lang` (#771) scope the word index BEFORE ranking
+ * (`searchWordIndex`'s `fileFilter`), so a surviving file's score is identical
+ * to an unfiltered run; omitting both reproduces prior output byte-for-byte.
+ *
+ * Every hit is additionally annotated (#771) with the graph signals already
+ * available when the cached review graph happens to be warm —
+ * `getCachedReviewGraph` (`clients/review-graph/builder.ts`) is a READ-ONLY
+ * accessor: an in-memory miss falls through to a persisted-disk read, and
+ * NOTHING here ever triggers a fresh build. A cold cache (no in-memory graph,
+ * no persisted snapshot) simply omits `annotations` — this function's latency
+ * profile is unchanged either way. The module is dynamic-imported (mirroring
+ * module-report.ts's own lazy load of it) so an unused review graph costs
+ * nothing on this hot path.
  */
-export function symbolSearch(query, cwd, limit = 20) {
+export async function symbolSearch(query, cwd, limit = 20, options = {}) {
     const snapshot = loadProjectSnapshot(cwd);
     const index = getOrLoadWarmWordIndex(cwd) ?? deserializeWordIndex(snapshot?.wordIndex);
     if (!index) {
@@ -114,11 +234,17 @@ export function symbolSearch(query, cwd, limit = 20) {
     // Boost well-connected files using the snapshot's reverse-dependency
     // (importedBy) counts; snapshot keys are normalized, index keys are raw.
     const centrality = centralityFromReverseDeps(index, snapshot?.reverseDeps, (file) => normalizeMapKey(path.resolve(file)));
-    const results = searchWordIndex(index, query, { limit, centrality });
+    const fileFilter = buildSymbolSearchFileFilter(cwd, options);
+    const results = searchWordIndex(index, query, { limit, centrality, fileFilter });
+    const hits = results.map(toSymbolSearchHit);
+    const { getCachedReviewGraph } = await import("./review-graph/builder.js");
+    const graph = getCachedReviewGraph(cwd);
+    if (graph)
+        annotateSymbolSearchHitsWithGraph(hits, centrality, graph);
     return {
         available: true,
         query,
-        results: results.map(toSymbolSearchHit),
+        results: hits,
         snapshotGeneratedAt: snapshot?.generatedAt,
     };
 }

package/dist/clients/lsp/cascade-tier.js

@@ -57,8 +57,7 @@ import { logCascade } from "../cascade-logger.js";
 import { logLatency } from "../latency-logger.js";
 import { normalizeMapKey } from "../path-utils.js";
 import { registerQuietWindowTask } from "../quiet-window.js";
-import { getServersForFileWithConfig } from "./config.js";
-import { getStrategy } from "./server-strategies.js";
+export { classifyCascadeWaitTier, classifyServerWaitTier, } from "./wait-policy/classification.js";
 // --- Kill switch (lazy, memoized — house style per clients/runtime-config.ts /
 // clients/quiet-window.ts's isQuietWindowEnabled) ---
 let _enabledCache;
@@ -75,42 +74,6 @@ export function isTierAwareCascadeEnabled() {
 export function _resetTierAwareCascadeEnabledForTests() {
     _enabledCache = undefined;
 }
-/**
- * Classify whether `filePath`'s PRIMARY language server is a cascade-lane
- * Tier-3 (push-only, silent-on-clean) server. Ambiguous or missing capability
- * data is always `"waits"` (today's behavior) — this function must never be
- * the reason a real answer gets missed.
- */
-export function classifyCascadeWaitTier(lspService, filePath, snapshots) {
-    void lspService; // kept in the signature for call-site clarity/typing only
-    const servers = getServersForFileWithConfig(filePath).filter((s) => s.role !== "auxiliary");
-    const primary = servers[0];
-    if (!primary)
-        return "waits";
-    const snapshot = snapshots.find((s) => s.serverId === primary.id);
-    if (!snapshot)
-        return "waits"; // no live snapshot yet — fail-safe
-    const mode = snapshot.workspaceDiagnosticsSupport?.mode;
-    if (mode !== "push-only")
-        return "waits"; // pull servers are always affirmative
-    const strategy = getStrategy(primary.id);
-    if (strategy.silentOnClean !== true)
-        return "waits"; // 2*/unknown push-only
-    // #524/#529/#541/#558: `silentOnClean` on a server-id-keyed strategy is
-    // only proven against the variant it was actually measured against.
-    // "typescript" today means either classic typescript-language-server
-    // (confirmed silent-on-clean, 2026-07-12 dual-environment re-measurement)
-    // or TS7's native `tsc --lsp --stdio` (the SAME re-measurement found it
-    // publishes 2 version-less diagnostic sets on clean — NOT silent, a
-    // drift from the earlier #541 measurement). A native-ts7 snapshot must
-    // NOT inherit the classic verdict: fall through to "waits", the same
-    // ambiguous/fail-safe path an unmarked or non-push-only server already
-    // takes. `launchVariant === "classic"` or absent (older snapshots that
-    // predate the marker) keeps today's tier-3 behavior exactly.
-    if (snapshot.launchVariant === "native-ts7")
-        return "waits";
-    return "tier3-silent";
-}
 // Keyed by normalized file path. A later touch for the same file simply
 // replaces the earlier entry (only the most recent touch matters — an
 // older touch's diagnostics, if they ever arrive, are still a strict superset

package/dist/clients/lsp/client.js

@@ -22,7 +22,7 @@ import { applyWorkspaceEdit } from "./edits.js";
 import { recordLspChild, removeLspChild } from "../instance-registry.js";
 import { normalizeMapKey, uriToPath } from "./path-utils.js";
 import { ADVERTISED_POSITION_ENCODINGS, convertCharacterOffset, lineTextAt, negotiatePositionEncoding, } from "./position-encoding.js";
-import { getStrategy } from "./server-strategies.js";
+import { getStrategy } from "./wait-policy/index.js";
 import { WatchedFilesQueue } from "./watch-queue.js";
 // Opt-in publishDiagnostics trace (PILENS_PUB_DEBUG=1) — read once, negligible
 // hot-path cost. Surfaces each server's publish behavior (version + count) to
@@ -703,6 +703,8 @@ export async function clientWaitForDiagnostics(state, filePath, timeoutMs, optio
             if (outcome.status === "clean")
                 sawClean = true;
         }
+        if (options.pullOnly)
+            return;
         if (outcome.status === "found" || sawClean)
             return;
     }