@herbertgao/pi-extensions 2026.9.1 → 2026.9.3

package/node_modules/pi-lens/dist/clients/test-runner-delivery.js

@@ -2,17 +2,14 @@
  * 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
+ * commit guard. This module stages an owner-qualified pointer and marks it
+ * eligible for the next context build 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";
+import { consumeTestFindings, peekTestFindings } from "./runtime-context.js";
 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
@@ -20,14 +17,6 @@ function key(cwd, sessionId, ownerId) {
     // 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,
@@ -44,9 +33,7 @@ function record(identity, outcome, delivery, metadata = {}) {
         },
     }, {
         capPerTurn: { limit: 8, turnIndex: delivery.generation },
-        ledgerKind: outcome === "delivery-failed" || outcome === "capability-unavailable"
-            ? "test-runner-delivery"
-            : undefined,
+        ledgerKind: outcome === "delivery-failed" ? "test-runner-delivery" : undefined,
         reason: `test runner delivery ${outcome}`,
     });
 }
@@ -70,6 +57,7 @@ export function stageTestRunnerDelivery(args) {
             generation: args.generation,
             targetCount: args.targetCount,
             createdAt: Date.now(),
+            eligible: false,
             owner: args.owner,
         };
         record(deliveryKey, "superseded", superseded, {
@@ -95,13 +83,14 @@ export function stageTestRunnerDelivery(args) {
         generation: args.generation,
         targetCount: args.targetCount,
         createdAt: Date.now(),
+        eligible: false,
         owner: args.owner,
     };
     pending.set(deliveryKey, delivery);
     prunePending();
     record(deliveryKey, "staged", delivery);
 }
-/** Deliver the latest staged result during a host-confirmed idle window. */
+/** Mark the latest staged result eligible 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);
@@ -112,16 +101,11 @@ export function deliverTestRunnerFindings(args) {
     if (currentGeneration !== undefined &&
         currentGeneration > delivery.generation) {
         pending.delete(deliveryKey);
-        record(deliveryKey, "superseded", delivery, {
-            currentGeneration,
-        });
+        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 {
@@ -136,14 +120,13 @@ export function deliverTestRunnerFindings(args) {
         });
         return;
     }
-    const findings = peekTestFindings(args.cacheManager, cwd, args.runtime, true);
-    if (!findings) {
+    if (!peekTestFindings(args.cacheManager, cwd, args.runtime, true)) {
         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.
+    // Recheck immediately before marking eligible. The host may accept a prompt
+    // between the first check and this synchronous call.
     try {
         if (!args.ctx.isIdle()) {
             record(deliveryKey, "carried", delivery);
@@ -156,32 +139,23 @@ export function deliverTestRunnerFindings(args) {
         });
         return;
     }
-    // SAFETY: appendEntry is an optional host capability absent from older Pi SDKs.
-    const appendEntry = args.pi.appendEntry;
-    if (typeof appendEntry !== "function") {
+    delivery.eligible = true;
+    const current = args.cacheManager.readCache("test-runner-findings", cwd)?.data;
+    if (!current?.content || current.testRunGeneration !== delivery.generation) {
         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,
+    args.cacheManager.writeCache("test-runner-findings", {
+        ...current,
+        deliveryEligible: {
             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),
-        });
-    }
+            eligibleAt: Date.now(),
+        },
+    }, cwd);
+    record(deliveryKey, "eligible", delivery, {
+        ageMs: Math.max(0, Date.now() - delivery.createdAt),
+    });
 }
 /** Deliver only the result staged by this activation and settled session. */
 export function deliverStagedTestRunnerFindings(args) {
@@ -195,7 +169,6 @@ export function deliverStagedTestRunnerFindings(args) {
     if (!delivery?.owner)
         return;
     deliverTestRunnerFindings({
-        pi: delivery.owner.pi,
         ctx: delivery.owner.getCtx(),
         cacheManager: delivery.owner.cacheManager,
         runtime: delivery.owner.runtime,
@@ -203,31 +176,63 @@ export function deliverStagedTestRunnerFindings(args) {
         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;
+/** Consume the result made eligible by the settled idle boundary. */
+export function consumeStagedTestRunnerFindings(args) {
+    const deliveryKey = key(args.cwd, args.sessionId, args.ownerId);
+    let delivery = pending.get(deliveryKey);
+    const persisted = args.cacheManager.readCache("test-runner-findings", args.cwd)?.data;
+    const eligible = persisted?.deliveryEligible;
+    if (!delivery && persisted?.content && eligible) {
+        const sameSession = eligible.sessionId === args.sessionId;
+        if (!sameSession) {
+            const foreignDelivery = {
+                cwd: args.cwd,
+                sessionId: eligible.sessionId,
+                generation: eligible.generation,
+                targetCount: 0,
+                createdAt: eligible.eligibleAt,
+                eligible: true,
+                rehydrated: true,
+            };
+            record(deliveryKey, "foreign-session", foreignDelivery, {
+                currentSessionId: args.sessionId,
+                currentOwnerId: args.ownerId,
+                reason: "session-mismatch",
+            });
+            return undefined;
+        }
+        delivery = {
+            cwd: args.cwd,
+            sessionId: args.sessionId,
+            ownerId: args.ownerId,
+            generation: eligible.generation,
+            targetCount: 0,
+            createdAt: eligible.eligibleAt,
+            eligible: true,
+            rehydrated: true,
+        };
+        pending.set(deliveryKey, delivery);
     }
-    catch {
-        return false;
+    if (!delivery?.eligible)
+        return undefined;
+    const currentGeneration = persisted?.testRunGeneration;
+    if (currentGeneration !== delivery.generation) {
+        pending.delete(deliveryKey);
+        record(deliveryKey, "superseded", delivery, { currentGeneration });
+        return undefined;
     }
-}
-function renderTestRunnerEntry(entry, _options, theme) {
-    const content = entry.data?.content;
-    if (typeof content !== "string")
+    const findings = consumeTestFindings(args.cacheManager, args.cwd, args.runtime);
+    if (!findings) {
+        pending.delete(deliveryKey);
+        record(deliveryKey, "superseded", delivery);
         return undefined;
-    const lines = [
-        theme.fg("error", "pi-lens test failures"),
-        ...content.split("\n"),
-    ];
-    return {
-        render: (width) => fitLines(lines, width),
-        invalidate: () => { },
-    };
+    }
+    pending.delete(deliveryKey);
+    record(deliveryKey, "delivered", delivery, {
+        ageMs: Math.max(0, Date.now() - delivery.createdAt),
+        rehydrated: delivery.rehydrated === true,
+    });
+    return findings;
 }
 /** Test-only reset; session ownership prevents cross-session consumption. */
 export function _resetTestRunnerDeliveryForTests() {

package/node_modules/pi-lens/dist/clients/tool-config.js

@@ -0,0 +1,199 @@
+/** Shared resolver for model-facing tool availability (#2800). */
+import { readFlagConfigValue } from "./lens-flag-registry.js";
+/** The complete model-facing tool population on pi and MCP. */
+export const TOOL_REGISTRY = [
+    {
+        name: "ast_grep_search",
+        piName: "ast_grep_search",
+        mcpName: "pilens_ast_grep_search",
+        situational: true,
+        summary: "AST-aware structural code search across ~40 languages (ast-grep patterns).",
+        disableable: true,
+    },
+    {
+        name: "ast_grep_replace",
+        piName: "ast_grep_replace",
+        mcpName: "pilens_ast_grep_replace",
+        situational: true,
+        summary: "AST-aware structural code rewrite/refactor (ast-grep patterns).",
+        disableable: true,
+    },
+    {
+        name: "ast_grep_outline",
+        piName: "ast_grep_outline",
+        mcpName: undefined,
+        situational: true,
+        summary: "Syntax-only file/dir structure (symbols/imports/exports/members) via ast-grep outline — no index/LSP.",
+        disableable: true,
+    },
+    {
+        name: "lsp_navigation",
+        piName: "lsp_navigation",
+        mcpName: "pilens_lsp_navigation",
+        situational: true,
+        summary: "IDE-style LSP navigation: definition, references, implementation, rename, call hierarchy.",
+        disableable: true,
+    },
+    {
+        name: "lens_diagnostics",
+        piName: "lens_diagnostics",
+        mcpName: "pilens_diagnostics",
+        disableable: true,
+    },
+    {
+        name: "lens_diagnostic_mark",
+        piName: "lens_diagnostic_mark",
+        mcpName: undefined,
+        situational: true,
+        summary: "Record a disposition for a diagnostic: false-positive / suppress (inline ignore comment) / defer (this session) / flagged (to fix).",
+        disableable: true,
+    },
+    {
+        name: "symbol_search",
+        piName: "symbol_search",
+        mcpName: "pilens_symbol_search",
+        disableable: true,
+    },
+    {
+        name: "module_report",
+        piName: "module_report",
+        mcpName: "pilens_module_report",
+        disableable: true,
+    },
+    {
+        name: "project_report",
+        piName: "project_report",
+        mcpName: "pilens_project_report",
+        disableable: true,
+    },
+    {
+        name: "read_symbol",
+        piName: "read_symbol",
+        mcpName: "pilens_read_symbol",
+        disableable: true,
+    },
+    {
+        name: "read_enclosing",
+        piName: "read_enclosing",
+        mcpName: "pilens_read_enclosing",
+        disableable: true,
+    },
+    {
+        name: "effective_config",
+        piName: "effective_config",
+        mcpName: "pilens_effective_config",
+        disableable: true,
+    },
+    {
+        name: "pi_lens_activate_tools",
+        piName: "pi_lens_activate_tools",
+        mcpName: undefined,
+        disableable: false,
+    },
+    {
+        name: "analyze",
+        piName: undefined,
+        mcpName: "pilens_analyze",
+        disableable: true,
+    },
+    {
+        name: "health",
+        piName: undefined,
+        mcpName: "pilens_health",
+        disableable: true,
+    },
+    {
+        name: "latency",
+        piName: undefined,
+        mcpName: "pilens_latency",
+        disableable: true,
+    },
+    {
+        name: "project_scan",
+        piName: undefined,
+        mcpName: "pilens_project_scan",
+        disableable: true,
+    },
+    {
+        name: "rebuild",
+        piName: undefined,
+        mcpName: "pilens_rebuild",
+        disableable: true,
+    },
+    {
+        name: "session_start",
+        piName: undefined,
+        mcpName: "pilens_session_start",
+        disableable: false,
+    },
+    {
+        name: "turn_end",
+        piName: undefined,
+        mcpName: "pilens_turn_end",
+        disableable: false,
+    },
+    {
+        name: "session_end",
+        piName: undefined,
+        mcpName: "pilens_session_end",
+        disableable: false,
+    },
+];
+export const LENS_TOOL_NAMES = TOOL_REGISTRY.map((tool) => tool.name);
+export function toolRegistryEntryForPi(name) {
+    return TOOL_REGISTRY.find((tool) => tool.piName === name);
+}
+export function toolRegistryEntryForMcp(name) {
+    return TOOL_REGISTRY.find((tool) => tool.mcpName === name);
+}
+/** Resolve one tool. CLI names are comma-separated to support repeatable flags. */
+export function resolveLensToolEnabled(name, globalConfig, projectConfig, cliNoTools) {
+    const entry = TOOL_REGISTRY.find((tool) => tool.name === name);
+    if (entry?.disableable === false)
+        return true;
+    const cliNames = Array.isArray(cliNoTools)
+        ? cliNoTools
+        : typeof cliNoTools === "string"
+            ? cliNoTools.split(",")
+            : [];
+    if (cliNames.some((entry) => entry.trim() === name))
+        return false;
+    const project = readFlagConfigValue(projectConfig, `tools.${name}.enabled`);
+    if (project !== undefined)
+        return project;
+    const global = readFlagConfigValue(globalConfig, `tools.${name}.enabled`);
+    return global ?? true;
+}
+/** Copy and validate the known per-tool leaves from one config document. */
+export function readToolConfig(raw, warnInvalid) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const section = raw.tools;
+    if (!section || typeof section !== "object" || Array.isArray(section))
+        return undefined;
+    const result = {};
+    for (const [name, value] of Object.entries(section)) {
+        if (name === "lazy")
+            continue;
+        const entry = TOOL_REGISTRY.find((tool) => tool.name === name);
+        if (!entry) {
+            warnInvalid(`unknown key "tools.${name}.enabled" is not a recognized pi-lens tool`, "PILENS_CFG_0009");
+            continue;
+        }
+        if (!entry.disableable) {
+            warnInvalid(`key "tools.${name}.enabled" cannot be disabled because it is required for the ${entry.mcpName ? "MCP session" : "pi tool activation"} contract`, "PILENS_CFG_0009");
+            continue;
+        }
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            warnInvalid(`tools.${name} must be an object with enabled`);
+            continue;
+        }
+        const enabled = value.enabled;
+        if (enabled !== undefined && typeof enabled !== "boolean") {
+            warnInvalid(`tools.${name}.enabled must be a boolean`);
+            continue;
+        }
+        result[name] = enabled === undefined ? {} : { enabled };
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}