pi-lens 3.8.73 → 4.0.0

package/dist/clients/tool-render.js

@@ -0,0 +1,155 @@
+/**
+ * Opt-in compact one-line tool-result rendering (#1327).
+ *
+ * pi renders a tool call as two rows by default: the tool-name/args row
+ * (`renderCall`) and the result row (`renderResult`). Most pi-lens tools
+ * already supply a `renderResult` via `tools/render-compact.ts`'s
+ * `compactRenderResult` — a collapsed one-line summary (brand-blue) plus the
+ * full output when expanded. This module adds a further, OPT-IN layer that
+ * collapses those two rows into ONE — `<status glyph> <name> — <summary>` —
+ * by reusing each tool's EXISTING collapsed summary text verbatim (never
+ * inventing new strings) and re-styling it through semantic `Theme` tokens
+ * instead of a fixed color.
+ *
+ * Applied generically at the registration seam (index.ts's registerTool
+ * loop), not as a per-tool copy: `wrapToolForCompactLine` decorates any
+ * `ToolDefinition` that already defines `renderResult`; tools without one are
+ * returned untouched. Callers gate the whole thing behind the `ui.compactToolLine`
+ * flag (`clients/lens-flag-registry.ts`) — when it is off, the ORIGINAL tool
+ * array is registered unwrapped, so behavior is byte-identical to today (no
+ * `renderCall`/`renderResult` are added or altered).
+ *
+ * `clients/` intentionally does NOT import `tools/render-compact.ts` (tools/
+ * depends on clients/, never the reverse — see AGENTS.md's seam discipline),
+ * so `fullTextOf` is duplicated here in miniature rather than inverting that
+ * dependency.
+ *
+ * API limitation vs the issue's ask: `ToolRenderResultOptions` (the type pi
+ * hands `renderResult`) exposes only `{ expanded, isPartial }` — no
+ * `outputPad`. `outputPad` exists solely on the unrelated `MessageRenderOptions`
+ * (custom message renderers, e.g. clients/turn-summary-render.ts), not on the
+ * tool-result render path. There is nothing to honor here; the collapsed line
+ * still respects the render width via `fitLines` so it never overflows the
+ * terminal (#513's crash class).
+ */
+import { stripAnsi } from "./sanitize.js";
+import { fitLines } from "./tui-fit.js";
+const EMPTY_COMPONENT = {
+    render: () => [],
+    invalidate: () => { },
+};
+function fullTextOf(result) {
+    return (result.content ?? [])
+        .filter((c) => c.type === "text" && typeof c.text === "string")
+        .map((c) => c.text)
+        .join("\n");
+}
+/**
+ * Build the collapsed compact line from a tool's ALREADY-COMPUTED summary
+ * text (verbatim reuse — see module doc). `summaryText` is expected in the
+ * `<name/hint> — <detail>` shape every pi-lens summarizer already produces
+ * (e.g. `lens_diagnostics all — 3 blocking · 3 errors · 2 warnings (1 file)`);
+ * when the separator is absent the whole string is styled as one span
+ * instead of guessing a split point.
+ *
+ * Pure and theme-driven: a status glyph (success/error tokens), the name
+ * portion (`toolTitle`, bold), and the detail portion (`error`/`toolOutput`)
+ * are each styled through semantic `Theme.fg` tokens — never a fixed color.
+ */
+export function buildCompactToolLine(summaryText, isError, theme) {
+    const glyph = isError ? theme.fg("error", "✗") : theme.fg("success", "✓");
+    const detailColor = isError ? "error" : "toolOutput";
+    const sepIndex = summaryText.indexOf(" — ");
+    if (sepIndex === -1) {
+        return `${glyph} ${theme.fg(detailColor, summaryText)}`;
+    }
+    const namePart = summaryText.slice(0, sepIndex);
+    const detailPart = summaryText.slice(sepIndex + " — ".length);
+    const styledName = theme.fg("toolTitle", theme.bold(namePart));
+    const styledDash = theme.fg("dim", "—");
+    const styledDetail = theme.fg(detailColor, detailPart);
+    return `${glyph} ${styledName} ${styledDash} ${styledDetail}`;
+}
+/** Render a component at a wide probe width to capture its full text,
+ * stripped of ANSI — the collapsed summary is re-styled through this
+ * module's own theme tokens rather than carrying over fixed-color escapes
+ * (e.g. tools/render-compact.ts's brand-blue). */
+function captureComponentText(component) {
+    try {
+        const lines = component.render(4096);
+        return stripAnsi(lines.join(" ")).trim();
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * Decorate a single tool definition with the opt-in compact-line renderers.
+ * Tools with no `renderResult` are returned UNCHANGED (nothing to compact).
+ * Call this only when the `ui.compactToolLine` flag is already known to be
+ * on — the caller (index.ts) skips the wrap entirely when it is off, which
+ * is what keeps the off path byte-identical to today rather than this
+ * function branching on a live flag read per render.
+ */
+export function wrapToolForCompactLine(tool) {
+    const originalRenderResult = tool.renderResult;
+    if (!originalRenderResult)
+        return tool;
+    const originalRenderCall = tool.renderCall;
+    const renderCall = (args, theme, context) => {
+        // Only blank the call row once a settled (non-partial) result exists —
+        // `renderResult` is about to paint the single combined line. While the
+        // tool is still running/streaming, keep showing the normal call row
+        // (mirrors the host's own createCallFallback) so the UI isn't blank.
+        if (!context.expanded && context.isPartial === false) {
+            return EMPTY_COMPONENT;
+        }
+        if (originalRenderCall)
+            return originalRenderCall(args, theme, context);
+        // Mirrors the host's own createCallFallback exactly: styled `tool.name`
+        // (the registered name, e.g. "lens_diagnostics"), not the display label.
+        const line = theme.fg("toolTitle", theme.bold(tool.name));
+        return {
+            render: (width) => fitLines([line], width),
+            invalidate: () => { },
+        };
+    };
+    const renderResult = (result, options, theme, context) => {
+        if (options.expanded) {
+            return originalRenderResult(result, options, theme, context);
+        }
+        let summaryText;
+        try {
+            // Probe the tool's OWN collapsed renderer to capture its already-built
+            // summary text; `lastComponent` is cleared so the probe never reuses
+            // (and thereby mutates) the real row's retained component.
+            const probeContext = { ...context, lastComponent: undefined };
+            const component = originalRenderResult(result, { ...options, expanded: false }, theme, probeContext);
+            summaryText = captureComponentText(component);
+        }
+        catch {
+            summaryText = "";
+        }
+        const resultLike = result;
+        if (!summaryText) {
+            summaryText = stripAnsi(fullTextOf(resultLike).split("\n")[0] ?? "").trim();
+        }
+        // pi invokes tool renderers with `{ content, details }` -- the failure
+        // bit lives on `context.isError`, not the result (#1341 review). Keep
+        // `result.isError` as a fallback for direct/legacy callers.
+        const contextIsError = context?.isError;
+        const isError = contextIsError ?? resultLike.isError === true;
+        const line = buildCompactToolLine(summaryText, isError === true, theme);
+        return {
+            render: (width) => fitLines([line], width),
+            invalidate: () => { },
+        };
+    };
+    return { ...tool, renderCall, renderResult };
+}
+/** Wrap every tool in an array — tools without `renderResult` pass through
+ * unchanged. Used by index.ts's registerTool loop, only when the
+ * `ui.compactToolLine` flag resolved on for this session. */
+export function wrapToolsForCompactLine(tools) {
+    return tools.map((tool) => wrapToolForCompactLine(tool));
+}

package/dist/clients/tree-sitter-cache.js

@@ -1,32 +1,75 @@
 /**
- * Tree-sitter Tree Cache with Incremental Parsing Support
+ * Tree-sitter Tree Cache
  *
- * Caches parsed ASTs and enables incremental updates for large files.
- * This provides 10-100× speedup on edits to large files (>1000 lines).
+ * Caches parsed ASTs so a file written once is parsed once and reused by every
+ * subsystem that inspects it in the same process (#675).
+ *
+ * Freshness is hash-authoritative when the caller supplies content: identical
+ * bytes parse to an identical tree, so a hash match is a hit even if the file's
+ * mtime moved (an agent re-saving unchanged bytes must not force a reparse,
+ * #890). Eviction is true LRU — hits re-insert their entry, so set() dropping
+ * the Map's first key removes the least-recently-used file, not merely the
+ * oldest insertion, and hot per-edit files survive scan traffic (#890).
  */
+import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
 import { normalizeFilePath } from "./path-utils.js";
+const TREE_RETIREMENT_GRACE_MICROTASKS = 4;
+export const TREE_CACHE_COUNTER_KEYS = [
+    "lookups",
+    "hits",
+    "coldMisses",
+    "capacityMisses",
+    "contentChangedMisses",
+    "mtimeMisses",
+    "statFailedMisses",
+    "sets",
+    "replacements",
+    "evictions",
+    "clears",
+    "ghostHistoryDrops",
+];
+export function createTreeCacheCounters() {
+    return Object.fromEntries(TREE_CACHE_COUNTER_KEYS.map((key) => [key, 0]));
+}
 export class TreeCache {
     cache = new Map();
+    recentlyEvicted = new Map();
     maxSize;
+    evictionHistoryMax;
     debug;
-    constructor(maxSize = 50, debug = false) {
+    counters = createTreeCacheCounters();
+    counterObserver;
+    treeErrorObserver;
+    constructor(maxSize = 50, debug = false, evictionHistoryMax = 4096, counterObserver, treeErrorObserver) {
         this.maxSize = maxSize;
+        this.evictionHistoryMax = Math.max(1, Math.floor(evictionHistoryMax));
+        this.counterObserver = counterObserver;
+        this.treeErrorObserver = treeErrorObserver;
         this.debug = debug
-            ? (msg) => console.error(`[tree-cache] ${msg}`)
+            ? (msg) => logTreeSitterDiagnostic({
+                subsystem: "tree-cache",
+                level: "debug",
+                message: msg,
+            })
             : () => { };
     }
+    recordCounter(key, amount = 1) {
+        this.counters[key] += amount;
+        this.counterObserver?.(key, amount);
+    }
     /**
      * Free a tree-sitter Tree's WASM-heap allocation.
      *
      * web-tree-sitter Trees live in the WASM heap; JS GC reclaims only the wrapper,
      * so the underlying memory leaks unless `tree.delete()` is called explicitly
      * (no FinalizationRegistry auto-free in 0.25). Guarded — a tree may already be
-     * deleted, or `delete()` may throw on a corrupt/aborted runtime. Safe because
-     * every consumer uses a returned tree transiently (parse → extract → discard
-     * within one call); the eviction target is always the OLDEST entry, never the
-     * just-parsed tree still in a caller's hand (#417).
+     * deleted, or `delete()` may throw on a corrupt/aborted runtime. Retirement is
+     * deferred so direct parse callers resume before deletion; consumers still
+     * traverse without another await, or use the cache-safe callback API (#417).
+     * The eviction target is the least-recently-used entry (get() re-inserts
+     * hits), never the just-parsed tree still in a caller's hand.
      */
     // biome-ignore lint/suspicious/noExplicitAny: web-tree-sitter Tree
     freeTree(tree) {
@@ -34,17 +77,39 @@ export class TreeCache {
             if (tree && typeof tree.delete === "function")
                 tree.delete();
         }
-        catch {
-            // best-effort — a dead wasm runtime or double-delete must not throw
+        catch (error) {
+            this.treeErrorObserver?.(error);
         }
     }
-    /** Remove a cache entry AND free its WASM tree. */
+    retireTree(tree) {
+        let remaining = TREE_RETIREMENT_GRACE_MICROTASKS;
+        const retire = () => {
+            if (remaining-- > 0) {
+                queueMicrotask(retire);
+                return;
+            }
+            this.freeTree(tree);
+        };
+        queueMicrotask(retire);
+    }
+    /** Remove a cache entry and retire its WASM tree after current consumers run. */
     removeEntry(key) {
         const cached = this.cache.get(key);
         if (cached)
-            this.freeTree(cached.tree);
+            this.retireTree(cached.tree);
         this.cache.delete(key);
     }
+    rememberEviction(key, cached) {
+        this.recentlyEvicted.delete(key);
+        if (this.recentlyEvicted.size >= this.evictionHistoryMax) {
+            const oldestKey = this.recentlyEvicted.keys().next().value;
+            if (oldestKey !== undefined) {
+                this.recentlyEvicted.delete(oldestKey);
+                this.recordCounter("ghostHistoryDrops");
+            }
+        }
+        this.recentlyEvicted.set(key, cached.contentHash);
+    }
     /**
      * Generate hash for file content
      */
@@ -62,28 +127,69 @@ export class TreeCache {
         return `${languageId}:${normalizeFilePath(filePath)}`;
     }
     /**
-     * Check if tree is cached and valid
+     * Check if tree is cached and valid.
+     *
+     * When `content` is provided the content hash is AUTHORITATIVE: a hash match
+     * is a hit regardless of mtime, and the entry's stat metadata is refreshed
+     * so a save-without-change (same bytes, newer mtime) does not masquerade as
+     * a disk modification (#890). The mtime check remains the freshness signal
+     * only on the content-less path, where nothing else can prove the cached
+     * tree current (`mtimeMisses`). A stat failure invalidates on both paths —
+     * a deleted file's entry is dead weight and its WASM tree should be freed.
+     *
+     * Every hit re-inserts the entry (raw Map delete+set — NOT removeEntry,
+     * which would retire the live tree) so eviction is true LRU (#890).
      */
     get(filePath, content, languageId) {
+        this.recordCounter("lookups");
         const key = this.getCacheKey(filePath, languageId);
         const cached = this.cache.get(key);
         if (!cached) {
+            const evictedHash = this.recentlyEvicted.get(key);
+            if (evictedHash !== undefined &&
+                content !== undefined &&
+                evictedHash === this.hashContent(content)) {
+                this.recordCounter("capacityMisses");
+            }
+            else {
+                this.recordCounter("coldMisses");
+            }
             this.debug(`Cache miss: ${filePath}`);
             return null;
         }
         // (No language-mismatch check needed: the cache key is prefixed with
         // languageId, so a key hit already implies the language matches.)
-        // Check content hash
-        const contentHash = this.hashContent(content);
-        if (cached.contentHash !== contentHash) {
-            this.debug(`Content changed: ${filePath} (${cached.lineCount} → ${content.split("\n").length} lines)`);
-            // Keep old tree for potential incremental update, but mark as stale
-            return null;
+        if (content !== undefined) {
+            // Check content hash — authoritative when content is provided.
+            const contentHash = this.hashContent(content);
+            if (cached.contentHash !== contentHash) {
+                this.recordCounter("contentChangedMisses");
+                this.debug(`Content changed: ${filePath} (${cached.lineCount} → ${content.split("\n").length} lines)`);
+                // Keep old tree for potential incremental update, but mark as stale
+                return null;
+            }
         }
-        // Check if file was modified on disk (mtime changed)
         try {
             const stats = fs.statSync(filePath);
-            if (stats.mtimeMs !== cached.lastModified) {
+            if (content !== undefined) {
+                // The hash already proved the tree current: an mtime delta is a
+                // save-without-change (or touch/clock drift). Refresh metadata
+                // instead of invalidating (#890). Caveat: this stamps the CURRENT
+                // disk mtime onto an entry validated against caller-supplied
+                // content — if that content lags a newer disk write, lastModified
+                // no longer vouches for the disk bytes. So lastModified means
+                // "mtime last observed on a hash-confirmed hit"; the content-less
+                // path below may only treat it as freshness proof while all
+                // callers pass content (today they all do — the undefined path is
+                // exercised only by tests).
+                if (stats.mtimeMs !== cached.lastModified) {
+                    cached.lastModified = stats.mtimeMs;
+                    this.debug(`Refreshed mtime on hash-matched entry: ${filePath}`);
+                }
+            }
+            else if (stats.mtimeMs !== cached.lastModified) {
+                // No content to hash — mtime is the only freshness proof.
+                this.recordCounter("mtimeMisses");
                 this.debug(`File modified on disk: ${filePath}`);
                 this.removeEntry(key);
                 return null;
@@ -91,9 +197,16 @@ export class TreeCache {
         }
         catch {
             // File might be deleted, invalidate cache
+            this.recordCounter("statFailedMisses");
             this.removeEntry(key);
             return null;
         }
+        // LRU touch: re-insert so this entry becomes the newest. The SAME entry
+        // object is re-set — no tree replacement, so nothing is retired and a
+        // retired tree can never be resurrected (#890).
+        this.cache.delete(key);
+        this.cache.set(key, cached);
+        this.recordCounter("hits");
         this.debug(`Cache hit: ${filePath} (${cached.lineCount} lines)`);
         return cached.tree;
     }
@@ -101,16 +214,26 @@ export class TreeCache {
      * Store parsed tree in cache
      */
     set(filePath, content, languageId, tree) {
+        this.recordCounter("sets");
         const key = this.getCacheKey(filePath, languageId);
+        const contentHash = this.hashContent(content);
+        this.recentlyEvicted.delete(key);
         // Free the tree we're about to replace at this key (re-parse of the same
         // file) so it doesn't leak its WASM heap.
         if (this.cache.has(key)) {
+            this.recordCounter("replacements");
             this.removeEntry(key);
         }
         else if (this.cache.size >= this.maxSize) {
-            // Evict + free the oldest entry when the cache is full.
+            // Evict + free the least-recently-used entry when the cache is full:
+            // get() re-inserts hits, so Map insertion order IS recency order and
+            // the first key is the LRU entry (#890).
             const firstKey = this.cache.keys().next().value;
             if (firstKey) {
+                const evicted = this.cache.get(firstKey);
+                if (evicted)
+                    this.rememberEviction(firstKey, evicted);
+                this.recordCounter("evictions");
                 this.removeEntry(firstKey);
                 this.debug(`Evicted: ${firstKey}`);
             }
@@ -125,136 +248,24 @@ export class TreeCache {
         }
         this.cache.set(key, {
             tree,
-            contentHash: this.hashContent(content),
+            contentHash,
             languageId,
-            fileSize: content.length,
+            fileSize: Buffer.byteLength(content, "utf8"),
             lineCount: content.split("\n").length,
             lastModified: mtime,
         });
         this.debug(`Cached: ${filePath} (${content.split("\n").length} lines)`);
     }
-    /**
-     * Calculate the diff between old and new content
-     * Returns edit information for incremental parsing
-     */
-    calculateEdit(oldContent, newContent) {
-        // Find the first difference
-        let startIndex = 0;
-        while (startIndex < oldContent.length &&
-            startIndex < newContent.length &&
-            oldContent[startIndex] === newContent[startIndex]) {
-            startIndex++;
-        }
-        // Find the last difference (working backwards)
-        let oldEndIndex = oldContent.length;
-        let newEndIndex = newContent.length;
-        while (oldEndIndex > startIndex &&
-            newEndIndex > startIndex &&
-            oldContent[oldEndIndex - 1] === newContent[newEndIndex - 1]) {
-            oldEndIndex--;
-            newEndIndex--;
-        }
-        // No change detected
-        if (startIndex === oldContent.length && startIndex === newContent.length) {
-            return null;
-        }
-        // Calculate positions
-        const startPosition = this.indexToPosition(oldContent, startIndex);
-        const oldEndPosition = this.indexToPosition(oldContent, oldEndIndex);
-        const newEndPosition = this.indexToPosition(newContent, newEndIndex);
-        return {
-            startIndex,
-            oldEndIndex,
-            newEndIndex,
-            startPosition,
-            oldEndPosition,
-            newEndPosition,
-        };
-    }
-    /**
-     * Convert byte index to row/column position
-     */
-    indexToPosition(content, index) {
-        const lines = content.slice(0, index).split("\n");
-        return {
-            row: lines.length - 1,
-            column: lines[lines.length - 1].length,
-        };
-    }
-    /**
-     * Attempt incremental update using tree.edit()
-     * Returns updated tree or null if incremental update failed
-     */
-    async incrementalUpdate(filePath, oldContent, newContent, languageId, parser) {
-        const key = this.getCacheKey(filePath, languageId);
-        const cached = this.cache.get(key);
-        if (!cached) {
-            this.debug(`No cached tree for incremental update: ${filePath}`);
-            return null;
-        }
-        // Only use incremental for large files (>100 lines)
-        const lineCount = oldContent.split("\n").length;
-        if (lineCount < 100) {
-            this.debug(`File too small for incremental: ${filePath} (${lineCount} lines)`);
-            return null;
-        }
-        // Calculate edit
-        const edit = this.calculateEdit(oldContent, newContent);
-        if (!edit) {
-            this.debug(`No edit detected for: ${filePath}`);
-            return null;
-        }
-        this.debug(`Incremental update: ${filePath} (lines ${edit.startPosition.row}-${edit.oldEndPosition.row})`);
-        try {
-            // Apply edit to tree
-            cached.tree.edit({
-                startIndex: edit.startIndex,
-                oldEndIndex: edit.oldEndIndex,
-                newEndIndex: edit.newEndIndex,
-                startPosition: edit.startPosition,
-                oldEndPosition: edit.oldEndPosition,
-                newEndPosition: edit.newEndPosition,
-            });
-            // Re-parse only changed region
-            const newTree = parser.parse(newContent, cached.tree);
-            // Update cache
-            this.set(filePath, newContent, languageId, newTree);
-            this.debug(`Incremental update successful: ${filePath}`);
-            return newTree;
-        }
-        catch (err) {
-            this.debug(`Incremental update failed: ${err}`);
-            return null;
-        }
-    }
-    /**
-     * Clear cache for a specific file
-     */
-    invalidate(filePath, languageId) {
-        if (languageId) {
-            const key = this.getCacheKey(filePath, languageId);
-            this.removeEntry(key);
-            this.debug(`Invalidated: ${key}`);
-        }
-        else {
-            // Invalidate all entries for this file
-            for (const [key, value] of this.cache.entries()) {
-                if (key.includes(filePath)) {
-                    this.freeTree(value.tree);
-                    this.cache.delete(key);
-                    this.debug(`Invalidated: ${key}`);
-                }
-            }
-        }
-    }
     /**
      * Clear entire cache
      */
     clear() {
+        this.recordCounter("clears");
         for (const entry of this.cache.values()) {
-            this.freeTree(entry.tree);
+            this.retireTree(entry.tree);
         }
         this.cache.clear();
+        this.recentlyEvicted.clear();
         this.debug("Cache cleared");
     }
     /**
@@ -268,10 +279,12 @@ export class TreeCache {
             totalBytes += entry.fileSize;
         }
         return {
+            ...this.counters,
             size: this.cache.size,
             maxSize: this.maxSize,
             totalLines,
             totalBytes,
+            misses: this.counters.lookups - this.counters.hits,
         };
     }
 }