pi-lens 4.1.2 → 4.1.4

package/dist/clients/test-runner-delivery.js

@@ -0,0 +1,239 @@
+/**
+ * Automatic test-runner delivery for the post-agent idle window (#2366).
+ *
+ * Test results remain in `test-runner-findings` for pull diagnostics and the
+ * commit guard. This module only stages an owner-qualified pointer and
+ * appends a non-context custom entry after the host proves that the agent is
+ * idle. Provenance validation stays in `peekTestFindings`, the one shared
+ * delivery gate for this cache.
+ */
+import { emitBounded } from "./bounded-telemetry.js";
+import { peekTestFindings } from "./runtime-context.js";
+import { fitLines } from "./tui-fit.js";
+export const TEST_RUNNER_ENTRY_TYPE = "pilens:test-runner-findings";
+const MAX_PENDING_DELIVERIES = 32;
+const MAX_ENTRY_CONTENT = 12_000;
+const pending = new Map();
+function key(cwd, sessionId, ownerId) {
+    // `cwd` comes from the same host session field at turn_end and settle. Keep
+    // that canonical value unchanged so cache reads use the identical workspace
+    // identity; dispatch contexts already normalize their own path fields.
+    return `${ownerId ?? "direct"}\u0000${cwd}\u0000${sessionId}`;
+}
+function boundedContent(content) {
+    if (content.length <= MAX_ENTRY_CONTENT)
+        return { content, droppedDetailCount: 0 };
+    return {
+        content: `${content.slice(0, MAX_ENTRY_CONTENT)}\n[…details truncated]`,
+        droppedDetailCount: content.length - MAX_ENTRY_CONTENT,
+    };
+}
+function record(identity, outcome, delivery, metadata = {}) {
+    emitBounded("test_runner_delivery", identity, {
+        filePath: delivery.cwd,
+        durationMs: 0,
+        metadata: {
+            outcome,
+            sessionId: delivery.sessionId,
+            generation: delivery.generation,
+            targetCount: delivery.targetCount,
+            deliveryBoundary: "agent_settled",
+            ownership: "pi",
+            droppedDetailCount: 0,
+            ...metadata,
+        },
+    }, {
+        capPerTurn: { limit: 8, turnIndex: delivery.generation },
+        ledgerKind: outcome === "delivery-failed" || outcome === "capability-unavailable"
+            ? "test-runner-delivery"
+            : undefined,
+        reason: `test runner delivery ${outcome}`,
+    });
+}
+function prunePending() {
+    while (pending.size > MAX_PENDING_DELIVERIES) {
+        const oldest = pending.keys().next();
+        if (oldest.done)
+            return;
+        pending.delete(oldest.value);
+    }
+}
+/** Stage the newest result for this session. Clean results supersede failures. */
+export function stageTestRunnerDelivery(args) {
+    const deliveryKey = key(args.cwd, args.sessionId, args.owner?.ownerId);
+    const prior = pending.get(deliveryKey);
+    if (prior && prior.generation > args.generation) {
+        const superseded = {
+            cwd: args.cwd,
+            sessionId: args.sessionId,
+            ownerId: args.owner?.ownerId,
+            generation: args.generation,
+            targetCount: args.targetCount,
+            createdAt: Date.now(),
+            owner: args.owner,
+        };
+        record(deliveryKey, "superseded", superseded, {
+            currentGeneration: prior.generation,
+        });
+        return;
+    }
+    if (!args.hasFindings) {
+        if (prior) {
+            pending.delete(deliveryKey);
+            record(deliveryKey, "superseded", {
+                ...prior,
+                targetCount: args.targetCount,
+                generation: args.generation,
+            });
+        }
+        return;
+    }
+    const delivery = {
+        cwd: args.cwd,
+        sessionId: args.sessionId,
+        ownerId: args.owner?.ownerId,
+        generation: args.generation,
+        targetCount: args.targetCount,
+        createdAt: Date.now(),
+        owner: args.owner,
+    };
+    pending.set(deliveryKey, delivery);
+    prunePending();
+    record(deliveryKey, "staged", delivery);
+}
+/** Deliver the latest staged result during a host-confirmed idle window. */
+export function deliverTestRunnerFindings(args) {
+    const cwd = args.ctx.cwd ?? process.cwd();
+    const deliveryKey = key(cwd, args.sessionId, args.ownerId);
+    const delivery = pending.get(deliveryKey);
+    if (!delivery)
+        return;
+    const currentGeneration = args.cacheManager.readCache("test-runner-findings", cwd)?.data?.testRunGeneration;
+    if (currentGeneration !== undefined &&
+        currentGeneration > delivery.generation) {
+        pending.delete(deliveryKey);
+        record(deliveryKey, "superseded", delivery, {
+            currentGeneration,
+        });
+        return;
+    }
+    if (typeof args.ctx.isIdle !== "function") {
+        pending.delete(deliveryKey);
+        record(deliveryKey, "capability-unavailable", delivery, {
+            reason: "host does not expose ctx.isIdle",
+        });
+        return;
+    }
+    try {
+        if (!args.ctx.isIdle()) {
+            record(deliveryKey, "carried", delivery);
+            return;
+        }
+    }
+    catch (error) {
+        record(deliveryKey, "delivery-failed", delivery, {
+            error: String(error).slice(0, 500),
+        });
+        return;
+    }
+    const findings = peekTestFindings(args.cacheManager, cwd, args.runtime, true);
+    if (!findings) {
+        pending.delete(deliveryKey);
+        record(deliveryKey, "superseded", delivery);
+        return;
+    }
+    // Recheck immediately before append. The host may accept a prompt between
+    // the first check and this synchronous call.
+    try {
+        if (!args.ctx.isIdle()) {
+            record(deliveryKey, "carried", delivery);
+            return;
+        }
+    }
+    catch (error) {
+        record(deliveryKey, "delivery-failed", delivery, {
+            error: String(error).slice(0, 500),
+        });
+        return;
+    }
+    // SAFETY: appendEntry is an optional host capability absent from older Pi SDKs.
+    const appendEntry = args.pi.appendEntry;
+    if (typeof appendEntry !== "function") {
+        pending.delete(deliveryKey);
+        record(deliveryKey, "capability-unavailable", delivery);
+        return;
+    }
+    const bounded = boundedContent(findings.messages[0]?.content ?? "");
+    try {
+        appendEntry.call(args.pi, TEST_RUNNER_ENTRY_TYPE, {
+            ...bounded,
+            sessionId: delivery.sessionId,
+            generation: delivery.generation,
+            targetCount: delivery.targetCount,
+        });
+        pending.delete(deliveryKey);
+        record(deliveryKey, "delivered", delivery, {
+            droppedDetailCount: bounded.droppedDetailCount,
+            ageMs: Math.max(0, Date.now() - delivery.createdAt),
+        });
+    }
+    catch (error) {
+        record(deliveryKey, "delivery-failed", delivery, {
+            error: String(error).slice(0, 500),
+        });
+    }
+}
+/** Deliver only the result staged by this activation and settled session. */
+export function deliverStagedTestRunnerFindings(args) {
+    if (!args?.cwd || !args.ownerId)
+        return;
+    const delivery = args.sessionId
+        ? pending.get(key(args.cwd, args.sessionId, args.ownerId))
+        : [...pending.values()]
+            .reverse()
+            .find((candidate) => candidate.cwd === args.cwd && candidate.ownerId === args.ownerId);
+    if (!delivery?.owner)
+        return;
+    deliverTestRunnerFindings({
+        pi: delivery.owner.pi,
+        ctx: delivery.owner.getCtx(),
+        cacheManager: delivery.owner.cacheManager,
+        runtime: delivery.owner.runtime,
+        sessionId: delivery.sessionId,
+        ownerId: delivery.ownerId,
+    });
+}
+export function registerTestRunnerEntryRenderer(pi) {
+    // SAFETY: registerEntryRenderer is an optional host capability absent from older Pi SDKs.
+    const register = pi.registerEntryRenderer;
+    if (typeof register !== "function")
+        return false;
+    try {
+        register.call(pi, TEST_RUNNER_ENTRY_TYPE, renderTestRunnerEntry);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function renderTestRunnerEntry(entry, _options, theme) {
+    const content = entry.data?.content;
+    if (typeof content !== "string")
+        return undefined;
+    const lines = [
+        theme.fg("error", "pi-lens test failures"),
+        ...content.split("\n"),
+    ];
+    return {
+        render: (width) => fitLines(lines, width),
+        invalidate: () => { },
+    };
+}
+/** Test-only reset; session ownership prevents cross-session consumption. */
+export function _resetTestRunnerDeliveryForTests() {
+    pending.clear();
+}
+/** Clear staged results when a primary session replaces the owning runtime. */
+export function resetTestRunnerDelivery() {
+    pending.clear();
+}

package/dist/clients/tool-definition.js

@@ -1,7 +1,47 @@
+/**
+ * THE final registration boundary for a host-facing tool: everything that
+ * must be true of a tool definition the instant before `pi.registerTool`
+ * sees it. `index.ts` runs every tool it registers — always-active,
+ * situational, and the compact-line-wrapped variants — through this one
+ * function, so a property added here reaches every tool without a second
+ * call site to keep in sync.
+ *
+ * Two jobs today:
+ *  1. metadata the host requires is present (a non-empty description);
+ *  2. an in-flight tool call HOLDS the event loop (#2507). pi-lens unrefs the
+ *     LSP child, its stdio pipes and several waiting timers so an idle
+ *     one-shot process can exit; in a headless child with no other referenced
+ *     handle that let Node exit 0 in the middle of `lsp_diagnostics`. Every
+ *     tool call therefore takes a counted hold for its own duration — see
+ *     `clients/event-loop-hold.ts` for why the hold lives there and not in
+ *     the unref itself.
+ */
+import { acquireEventLoopHold } from "./event-loop-hold.js";
 export function normalizeToolDefinition(tool) {
     const name = typeof tool.name === "string" ? tool.name.trim() : "tool";
     const description = typeof tool.description === "string" && tool.description.trim().length > 0
         ? tool.description
         : `Use the ${name} tool.`;
-    return { ...tool, description };
+    const execute = tool.execute;
+    if (typeof execute !== "function") {
+        return { ...tool, description };
+    }
+    const inner = execute;
+    return {
+        ...tool,
+        description,
+        // A plain function, not an arrow: `this` stays whatever the host called
+        // the tool with, so a definition whose `execute` reads `this` keeps
+        // working. The hold is released in `finally`, so a rejected or aborted
+        // call releases exactly like a resolved one.
+        execute: async function (...args) {
+            const release = acquireEventLoopHold(name);
+            try {
+                return await inner.apply(this, args);
+            }
+            finally {
+                release();
+            }
+        },
+    };
 }

package/dist/clients/tool-policy.js

@@ -176,7 +176,10 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
         {
             formatterNames: ["prettier"],
             defaultFormatter: "prettier",
-            defaultWhenUnconfigured: true,
+            // HTML commonly carries template markers ({{JS}} embeds, Handlebars,
+            // Helm-adjacent Go templates). Prettier reinterprets them as code and
+            // corrupts them. Opt in via project prettier config; do not run by default.
+            defaultWhenUnconfigured: false,
             gate: "smart-default",
         },
     ],
@@ -185,7 +188,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
         {
             formatterNames: ["prettier"],
             defaultFormatter: "prettier",
-            defaultWhenUnconfigured: true,
+            defaultWhenUnconfigured: false,
             gate: "smart-default",
         },
     ],
@@ -194,7 +197,10 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
         {
             formatterNames: ["prettier"],
             defaultFormatter: "prettier",
-            defaultWhenUnconfigured: true,
+            // YAML commonly carries template markers (Helm `{{ .Values.x }}`,
+            // Ansible `{{ var }}`). Prettier splits `{{` into `{ {` and reindents
+            // embedded templates. Opt in via project prettier config.
+            defaultWhenUnconfigured: false,
             gate: "smart-default",
         },
     ],
@@ -203,7 +209,7 @@ const FORMATTER_POLICY_BY_EXTENSION = new Map([
         {
             formatterNames: ["prettier"],
             defaultFormatter: "prettier",
-            defaultWhenUnconfigured: true,
+            defaultWhenUnconfigured: false,
             gate: "smart-default",
         },
     ],
@@ -984,7 +990,7 @@ const TOOL_COMMAND_SPECS = new Map([
         {
             command: "markdownlint-cli2",
             windowsExt: ".cmd",
-            versionArgs: ["--version"],
+            versionArgs: ["--no-globs", "-"],
             managedToolId: "markdownlint",
         },
     ],
@@ -2236,8 +2242,14 @@ export function _getSpotlessGradleReadCountForTests() {
  * executable Gradle source. This is deliberately a small lexical pre-pass,
  * not a Groovy/Kotlin parser. In particular, statically disabled constructs
  * such as `if (false) { ktlint() }` remain a documented false-positive.
+ *
+ * Exported (with `gradleBlockRanges` below) so `clients/gradle-ktfmt-
+ * style.ts` (#2468) reuses this exact pre-pass for the `ktfmt { }` extension
+ * block instead of a second hand-rolled Gradle lexer — the same
+ * single-source-of-truth reuse `clients/cargo-manifest.ts` did for TOML
+ * parsing (#2466).
  */
-function stripGradleCommentsAndStrings(source) {
+export function stripGradleCommentsAndStrings(source) {
     let result = "";
     let state = "code";
     let quote = "";
@@ -2303,24 +2315,82 @@ function stripGradleCommentsAndStrings(source) {
     }
     return result;
 }
-function namedGradleBlockBodies(source, name) {
-    const bodies = [];
-    const startPattern = new RegExp(`\\b${name}\\s*\\{`, "g");
-    for (const match of source.matchAll(startPattern)) {
-        const open = source.indexOf("{", match.index);
-        let depth = 1;
-        for (let index = open + 1; index < source.length; index += 1) {
-            if (source[index] === "{")
-                depth += 1;
-            if (source[index] === "}")
-                depth -= 1;
-            if (depth === 0) {
-                bodies.push(source.slice(open + 1, index));
-                break;
-            }
+const GRADLE_IDENTIFIER_CHAR = /[A-Za-z0-9_$]/;
+/**
+ * The identifier immediately preceding a `{`, or `""`. Mirrors the
+ * `\b<name>\s*\{` shape the named lookup used before it became a filter over
+ * this scanner: whitespace (including newlines) between the name and the
+ * brace is skipped, and `.` ends the identifier so `com.ncorti.ktfmt { }`
+ * still reads as `ktfmt` while `something_ktfmt { }` does not.
+ */
+function gradleBlockNameBefore(source, open) {
+    let index = open - 1;
+    while (index >= 0 && /\s/.test(source[index]))
+        index -= 1;
+    const end = index + 1;
+    while (index >= 0 && GRADLE_IDENTIFIER_CHAR.test(source[index]))
+        index -= 1;
+    return source.slice(index + 1, end);
+}
+/**
+ * Body ranges of EVERY brace pair in `source`, in source order, each labelled
+ * with the identifier that introduced it.
+ *
+ * This is the repo's only Gradle brace scanner: `namedGradleBlockRanges` and
+ * `namedGradleBlockBodies` are filters over it. Scanning every pair — rather
+ * than only the pairs whose name a caller thought to ask about — is what lets
+ * `clients/gradle-ktfmt-style.ts` (#2468 review round 3) answer "what block
+ * ENCLOSES this one?" instead of only "is it inside the one name I checked?".
+ * The distinction is load-bearing there: `configure(subprojects.filter { … })
+ * { ktfmt { } }`, `project(":app") { ktfmt { } }` and a convention-plugin
+ * wrapper all have to be recognized as *some* enclosing scope the resolver
+ * cannot evaluate, so it can fail closed rather than treat the block as
+ * top-level.
+ *
+ * Unbalanced braces are best-effort: an unmatched `}` is ignored and an
+ * unclosed `{` yields no range, exactly as the previous per-name depth scan
+ * behaved.
+ */
+export function gradleBlockRanges(source) {
+    const ranges = [];
+    const opens = [];
+    for (let index = 0; index < source.length; index += 1) {
+        const char = source[index];
+        if (char === "{") {
+            opens.push(index);
+            continue;
         }
+        if (char !== "}")
+            continue;
+        const open = opens.pop();
+        if (open === undefined)
+            continue;
+        ranges.push({
+            name: gradleBlockNameBefore(source, open),
+            start: open + 1,
+            end: index,
+        });
     }
-    return bodies;
+    // Pairs are completed innermost-first; callers want source order.
+    return ranges.sort((a, b) => a.start - b.start);
+}
+/**
+ * Body ranges of every `<name> { ... }` block, in source order.
+ *
+ * The offsets exist so a caller can ask where a block sits RELATIVE to
+ * another one — `clients/gradle-ktfmt-style.ts` (#2468) needs to know which
+ * block encloses a `ktfmt { }` one, because Gradle's `subprojects { }`
+ * applies it to the children and NOT to the project declaring it, while
+ * `allprojects { }` applies to both. Containment of two ranges is the only
+ * reliable way to answer that; matching body TEXT would collide whenever two
+ * blocks happen to have identical bodies. `namedGradleBlockBodies` stays the
+ * ergonomic form for callers that only need the text.
+ */
+function namedGradleBlockRanges(source, name) {
+    return gradleBlockRanges(source).filter((range) => range.name === name);
+}
+function namedGradleBlockBodies(source, name) {
+    return namedGradleBlockRanges(source, name).map((range) => source.slice(range.start, range.end));
 }
 /**
  * Resolve the formatter elected by a Spotless `kotlin { ... }` block.

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

@@ -14,6 +14,7 @@
 import { logTreeSitterDiagnostic } from "./tree-sitter-logger.js";
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
+import { BoundedFifoMap } from "./bounded-cache.js";
 import { normalizeFilePath } from "./path-utils.js";
 const TREE_RETIREMENT_GRACE_MICROTASKS = 4;
 export const TREE_CACHE_COUNTER_KEYS = [
@@ -82,17 +83,23 @@ export function deriveScanTreeCacheCapacity(fileCount, currentMaxSize) {
     return Math.max(currentMaxSize, target);
 }
 export class TreeCache {
-    cache = new Map();
-    recentlyEvicted = new Map();
-    maxSize;
+    // BoundedFifoMap, not BoundedLruCache, even though eviction here IS true
+    // LRU: recency is refreshed by this class's own explicit `delete`+`set`
+    // touch on a VALIDATED hit (see `get`), and only there. A `get` that
+    // promoted on every read would also promote entries `get` goes on to
+    // reject (content-hash mismatch returns null without removing), silently
+    // changing which entry eviction targets (#2442 review F7).
+    cache = new BoundedFifoMap(TREE_CACHE_DEFAULT_MAX_SIZE);
+    recentlyEvicted;
     evictionHistoryMax;
     debug;
     counters = createTreeCacheCounters();
     counterObserver;
     treeErrorObserver;
     constructor(maxSize = TREE_CACHE_DEFAULT_MAX_SIZE, debug = false, evictionHistoryMax = 4096, counterObserver, treeErrorObserver) {
-        this.maxSize = maxSize;
+        this.cache.setMaxEntries(Math.max(1, Math.floor(maxSize)));
         this.evictionHistoryMax = Math.max(1, Math.floor(evictionHistoryMax));
+        this.recentlyEvicted = new BoundedFifoMap(this.evictionHistoryMax);
         this.counterObserver = counterObserver;
         this.treeErrorObserver = treeErrorObserver;
         this.debug = debug
@@ -109,7 +116,7 @@ export class TreeCache {
     }
     /** Current capacity ceiling (entry count, not bytes — see class docstring). */
     getMaxSize() {
-        return this.maxSize;
+        return this.cache.getMaxEntries();
     }
     /**
      * Resize the capacity ceiling (#1715). Growing only changes the bound —
@@ -120,17 +127,24 @@ export class TreeCache {
      * entries can never record a hit.
      */
     setMaxSize(n) {
-        const next = Math.max(1, Math.floor(n));
-        this.maxSize = next;
-        while (this.cache.size > this.maxSize) {
-            const firstKey = this.cache.keys().next().value;
-            if (firstKey === undefined)
-                break;
-            const evicted = this.cache.get(firstKey);
-            if (evicted)
-                this.rememberEviction(firstKey, evicted);
+        this.retireEvicted(this.cache.setMaxEntries(Math.max(1, Math.floor(n))));
+    }
+    /**
+     * Book-keep entries the bounded map dropped: ghost history, the eviction
+     * counter, and the WASM-heap tree retirement (#417/#890) that made this
+     * cache's eviction side-effect-coupled in the first place. One
+     * implementation, shared by the two paths that can overflow
+     * ({@link setMaxSize} and {@link set}) — the shape `BoundedFifoMap.set`'s
+     * `[key, value]` return exists to enable (#2442 review F7).
+     */
+    retireEvicted(evicted) {
+        for (const [key, cached] of evicted) {
+            this.rememberEviction(key, cached);
             this.recordCounter("evictions");
-            this.removeEntry(firstKey);
+            // The bounded map already removed the entry, so retire the tree
+            // directly rather than through removeEntry's re-lookup.
+            this.retireTree(cached.tree);
+            this.debug(`Evicted: ${key}`);
         }
     }
     /**
@@ -175,14 +189,9 @@ export class TreeCache {
     }
     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);
+        const dropped = this.recentlyEvicted.set(key, cached.contentHash);
+        if (dropped.length > 0)
+            this.recordCounter("ghostHistoryDrops");
     }
     /**
      * Generate hash for file content
@@ -298,20 +307,11 @@ export class TreeCache {
             this.recordCounter("replacements");
             this.removeEntry(key);
         }
-        else if (this.cache.size >= this.maxSize) {
-            // 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}`);
-            }
-        }
+        // Overflow eviction itself now happens on the `this.cache.set` below —
+        // the bounded map evicts the least-recently-used entry (this class's
+        // explicit delete+set touch on a validated hit makes insertion order
+        // recency order, #890) and hands back the dropped [key, tree] pair for
+        // `retireEvicted` to free.
         let mtime = 0;
         try {
             mtime = fs.statSync(filePath).mtimeMs;
@@ -320,14 +320,14 @@ export class TreeCache {
             // File deleted between parse and cache — cache with mtime=0;
             // next get() will miss on mtime check and re-parse
         }
-        this.cache.set(key, {
+        this.retireEvicted(this.cache.set(key, {
             tree,
             contentHash,
             languageId,
             fileSize: Buffer.byteLength(content, "utf8"),
             lineCount: content.split("\n").length,
             lastModified: mtime,
-        });
+        }));
         this.debug(`Cached: ${filePath} (${content.split("\n").length} lines)`);
     }
     /**
@@ -355,7 +355,7 @@ export class TreeCache {
         return {
             ...this.counters,
             size: this.cache.size,
-            maxSize: this.maxSize,
+            maxSize: this.cache.getMaxEntries(),
             totalLines,
             totalBytes,
             misses: this.counters.lookups - this.counters.hits,