pi-lens 3.8.71 → 3.8.73

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;
     }