pi-lens 4.2.1 → 4.4.0

package/dist/clients/turn-summary.js

@@ -1,132 +0,0 @@
-/**
- * Turn-summary collector (#484).
- *
- * Opt-in, transcript-persistent record of what pi-lens did: diagnostics
- * found, autofixes applied, autoformats applied. Accumulated per-file across
- * the RUN's write/edit pipeline runs + the agent_end deferred-format pass,
- * then emitted as ONE `pi.sendMessage` custom entry at the `agent_settled`
- * quiet window (never per-file, and per-RUN not per-turn — see the #484
- * discussion + PR #500 review). The quiet-window emit point is load-bearing,
- * not cosmetic (verified in the installed pi 0.80.6 SDK):
- *
- *   1. `sendCustomMessage` STEERS the live model conversation when the
- *      session `isStreaming` (dist/core/agent-session.js), and turn_end can
- *      fire mid-stream — a passive summary must never steer a working agent.
- *      At settle the session is idle, so sendMessage takes the safe append
- *      branch (persisted + rendered immediately, no steer).
- *   2. A CustomMessageEntry DOES participate in LLM context: `display` only
- *      controls TUI rendering, and `buildSessionContext` converts every such
- *      entry into a `role: "user"` message on later context builds
- *      (dist/core/session-manager.js). Only `content` reaches the model —
- *      `details` never does — so the entry `content` must stay ONE short
- *      line; the model's exposure is that ~80-char collapsed line, an
- *      accepted residue (largely redundant with the #493 agent nudge).
- *
- * Collapsed rendering is tool-grouped; expanded rendering (from `details`,
- * human-only) is file-major.
- *
- * All map keys go through `normalizeMapKey` — never a hand-rolled path
- * comparison (see the two red CI rounds on PR #491 the raw-key trap cost).
- */
-import { normalizeMapKey } from "./path-utils.js";
-/**
- * Per-RUN accumulator. One instance lives on the runtime coordinator; it
- * survives turn boundaries (NOT cleared in beginTurn) and is cleared only by
- * `consume()` at the quiet-window emit and by `resetForSession()`.
- */
-export class TurnSummaryCollector {
-    filesByKey = new Map();
-    getOrCreate(filePath) {
-        const key = normalizeMapKey(filePath);
-        let entry = this.filesByKey.get(key);
-        if (!entry) {
-            // displayPath is resolved at consume() time (cwd known there); the
-            // accumulation phase only has the absolute path.
-            entry = { filePath, displayPath: filePath, events: [] };
-            this.filesByKey.set(key, entry);
-        }
-        return entry;
-    }
-    record(filePath, event) {
-        this.getOrCreate(filePath).events.push(event);
-    }
-    recordDiagnostic(filePath, args) {
-        this.record(filePath, { kind: "diagnostic", ...args });
-    }
-    recordAutofix(filePath, args) {
-        this.record(filePath, { kind: "autofix", ...args });
-    }
-    recordFormat(filePath, args) {
-        this.record(filePath, { kind: "format", ...args });
-    }
-    isEmpty() {
-        return this.filesByKey.size === 0;
-    }
-    /** Snapshot without clearing — used for tests/observability. */
-    peek() {
-        return [...this.filesByKey.values()];
-    }
-    clear() {
-        this.filesByKey.clear();
-    }
-    /** Consume (snapshot + clear) the run's collection, building the details payload. */
-    consume(turnIndex, toDisplayPath) {
-        const files = [...this.filesByKey.values()].map((entry) => ({
-            ...entry,
-            displayPath: toDisplayPath
-                ? toDisplayPath(entry.filePath)
-                : entry.filePath,
-        }));
-        this.filesByKey.clear();
-        const counts = {
-            diagnostics: 0,
-            autofixes: 0,
-            formats: 0,
-            byTool: { diagnostic: {}, autofix: {}, format: {} },
-        };
-        for (const file of files) {
-            for (const event of file.events) {
-                if (event.kind === "diagnostic")
-                    counts.diagnostics++;
-                else if (event.kind === "autofix")
-                    counts.autofixes++;
-                else
-                    counts.formats++;
-                const bucket = counts.byTool[event.kind];
-                bucket[event.tool] = (bucket[event.tool] ?? 0) + 1;
-            }
-        }
-        return { version: 1, turnIndex, files, counts };
-    }
-}
-function formatToolCounts(byTool) {
-    return Object.entries(byTool)
-        .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
-        .map(([tool, count]) => `${tool} ${count}`)
-        .join(", ");
-}
-/**
- * Build the collapsed, tool-grouped one-line fallback text (also used as the
- * plain-text `content` for hosts without the custom renderer).
- * Example: "pi-lens: 3 diagnostics (eslint 2, tsserver 1) · 2 autofixed (ruff) · 1 reformatted (prettier)"
- */
-export function formatTurnSummaryLine(details) {
-    const parts = [];
-    const { counts } = details;
-    if (counts.diagnostics > 0) {
-        const byTool = formatToolCounts(counts.byTool.diagnostic);
-        parts.push(`${counts.diagnostics} diagnostic${counts.diagnostics === 1 ? "" : "s"}${byTool ? ` (${byTool})` : ""}`);
-    }
-    if (counts.autofixes > 0) {
-        const byTool = formatToolCounts(counts.byTool.autofix);
-        parts.push(`${counts.autofixes} autofixed${byTool ? ` (${byTool})` : ""}`);
-    }
-    if (counts.formats > 0) {
-        const byTool = formatToolCounts(counts.byTool.format);
-        parts.push(`${counts.formats} reformatted${byTool ? ` (${byTool})` : ""}`);
-    }
-    if (parts.length === 0)
-        return "pi-lens: turn summary (empty)";
-    return `pi-lens: ${parts.join(" · ")}`;
-}
-export const TURN_SUMMARY_CUSTOM_TYPE = "pilens:turn-summary";

package/dist/clients/typos-config.js

@@ -1,29 +0,0 @@
-import { findLocalToolConfig } from "./path-utils.js";
-/**
- * typos (source-code spell checker) configuration discovery. typos runs as a
- * cross-cutting auxiliary LSP (#283); like Opengrep's local-rules gate and
- * zizmor's `zizmor.yml` gate, the PRESENCE of a repo-local typos config is the
- * project's deliberate opt-in to let spelling findings BLOCK (it carries the
- * team's curated allow-list / `extend-words` / severity). Advisory otherwise.
- *
- * typos discovers its config as `typos.toml`, `_typos.toml`, or `.typos.toml`
- * at the project root (see typos' configuration docs). We only need to know if
- * one EXISTS for the blocking gate — the `typos-lsp` server reads it itself.
- *
- * Note: `files.*` ignore globs in the config have NO effect under the LSP
- * (CLI-only), so a `.typos.toml` does not exclude paths from the LSP scan — it
- * only tunes the dictionary/severity. The blocking gate keys purely on presence.
- */
-export const LOCAL_TYPOS_CONFIG_NAMES = [
-    "typos.toml",
-    "_typos.toml",
-    ".typos.toml",
-];
-// Deliberately UNCEILINGED at $HOME (refs #2472 review round 3, F1): typos
-// discovers `~/typos.toml` as the user's legitimate global config, and
-// `typos-lsp` merges an injected config with its own discovery (injected
-// wins) — a ceilinged search here silently hid the user's config from that
-// merge and let pi-lens's own shipped `_typos.toml` clobber it instead.
-export function findLocalTyposConfig(startDir) {
-    return findLocalToolConfig(startDir, LOCAL_TYPOS_CONFIG_NAMES);
-}

package/dist/clients/user-notify.js

@@ -1,51 +0,0 @@
-/**
- * The HUMAN channel for degradations discovered deep in `clients/` (#1333).
- *
- * Most of what the migrated `console.*` sites emitted is LOG-audience and
- * belongs in an ndjson sink (`clients/extension-log.ts`). A small set is
- * genuinely user-facing — "the config file you wrote is being ignored", "this
- * language's grammar could not be fetched, so its structural features are
- * degraded", "the WASM runtime aborted; restart to recover". Those must reach
- * the human through the HOST's own render path, never a raw terminal write
- * (pi owns the terminal — see the module doc in `extension-log.ts`).
- *
- * `index.ts` wires a getter at extension init; modules deep in the tree call
- * `notifyUserDegradation` without knowing anything about `ctx`. Per the
- * #338/#798 detached-callback rule the notifier is resolved through a GETTER
- * at delivery time — never captured once, because a session replacement
- * invalidates the previously captured `ctx.ui`.
- *
- * Fail-soft by construction: with no host wired (MCP server, CLI, tests) this
- * is a no-op and the ndjson sink remains the sole destination — the message is
- * never lost, only un-rendered.
- */
-import { withConfigDiagnosticCode, } from "./config-diagnostic-codes.js";
-let notifierGetter;
-/** Called once from the extension entry with a getter over the live `ctx.ui.notify`. */
-export function wireUserNotifier(portsOrGetter) {
-    notifierGetter =
-        typeof portsOrGetter === "function"
-            ? portsOrGetter
-            : () => portsOrGetter.notify.user;
-}
-/** Test/teardown-only: drop the wired host. */
-export function resetUserNotifier() {
-    notifierGetter = undefined;
-}
-/**
- * Best-effort delivery of a user-facing degradation. Never throws — a stale
- * `ctx` after a session replacement must degrade to a no-op, not break the
- * diagnostic path that called it.
- */
-export function notifyUserDegradation(message, level = "warning", options) {
-    try {
-        const notify = notifierGetter?.();
-        const coded = options?.code
-            ? withConfigDiagnosticCode(message, options.code)
-            : message;
-        notify?.(coded, level);
-    }
-    catch {
-        // The ndjson sink already holds this message; a dead host is not an error.
-    }
-}

package/dist/clients/vanished-instance-marker.js

@@ -1,57 +0,0 @@
-/**
- * Vanished-instance markers (#1123 item 2, first slice — instance health).
- *
- * `deregisterInstance()` (clients/instance-registry.ts) SYNCHRONOUSLY removes
- * a process's own entry from `instances.json` on a clean `session_shutdown`.
- * That means the entry's mere PRESENCE in the registry, combined with a
- * pid-confirmed-dead owner, is already proof the process never reached that
- * shutdown path — no separate "clean shutdown" flag is needed on
- * `InstanceEntry` (the registry already carries `heartbeatAt`/`rssBytes`,
- * which is exactly the "lastSeen"/"rss" pair this marker needs; both are
- * used AS-IS, per the instruction to add fields only if missing).
- *
- * `sweepOrphans()` (clients/instance-reaper.ts) already prunes these exact
- * dead-pid entries out of the registry as part of #472's orphan-LSP reap —
- * so this marker's read MUST happen against a snapshot taken before (or
- * independently of) that prune, or the vanished set will already be empty by
- * the time this runs. `logVanishedInstances` therefore takes the registry
- * snapshot as an argument rather than reading it itself, so the caller
- * controls ordering (see index.ts's session_start wiring, which reads once
- * and passes the same snapshot to both this marker and `sweepOrphans`).
- */
-import { logSessionStart } from "./sessionstart-logger.js";
-import { realIsPidAlive } from "./instance-reaper.js";
-/**
- * PURE: registry entries whose owning pid is confirmed dead. Every such entry
- * is, by construction (see module docstring), one that exited without
- * reaching `deregisterInstance()`. Uses the SAME conservative liveness
- * contract as the reaper (`isPidAlive`, defaulting to `realIsPidAlive`):
- * ESRCH-only-means-dead, any ambiguous signal (EPERM, unknown) stays "alive"
- * — never flag a live-but-unverifiable instance as vanished.
- */
-export function detectVanishedInstances(registry, isPidAlive) {
-    return registry
-        .filter((entry) => !isPidAlive(entry.pid))
-        .map((entry) => ({
-        pid: entry.pid,
-        lastSeenAt: entry.heartbeatAt,
-        rssBytes: entry.rssBytes ?? 0,
-    }));
-}
-/**
- * Log one `sessionstart.log` line per vanished instance found in `registry`.
- * Best-effort (never throws into `session_start`) and read-only — this
- * function never mutates or prunes the registry; that stays the reaper's job.
- */
-export function logVanishedInstances(registry, isPidAlive = realIsPidAlive) {
-    try {
-        const vanished = detectVanishedInstances(registry, isPidAlive);
-        for (const instance of vanished) {
-            const rssMb = Math.round(instance.rssBytes / (1024 * 1024));
-            logSessionStart(`previous instance pid ${instance.pid} last seen ${instance.lastSeenAt} (RSS ${rssMb}MB) exited without shutdown`);
-        }
-    }
-    catch {
-        // best-effort observability — never fail session_start over this
-    }
-}

package/dist/clients/warm-attach.js

@@ -1,246 +0,0 @@
-import * as fs from "node:fs";
-import * as net from "node:net";
-import * as path from "node:path";
-import { readInstanceRegistry, selectLivePeerInstances, } from "./instance-registry.js";
-import { realIsPidAlive } from "./instance-reaper.js";
-import { logLatency } from "./latency-logger.js";
-import { touchCoverageGap } from "./lsp/diagnostic-binding.js";
-import { loadLspService } from "./lsp-lazy.js";
-import { contentHash, createWarmIpcLineReader, diagnosticsIpcPathForCwd, requestWarmCodeActions, requestWarmDiagnostics, WARM_CODE_ACTION_LOOKUP_LIMIT, WARM_DIAGNOSTICS_SCHEMA_VERSION, } from "./mcp/ipc.js";
-import { normalizeFilePath } from "./path-utils.js";
-const state = { local: true, servedDiagnosticHashes: new Map() };
-function record(event, cwd, reason, pid, source) {
-    logLatency({
-        type: "phase",
-        phase: "lsp_warm_attach",
-        filePath: cwd,
-        durationMs: 0,
-        metadata: { event, reason, incumbentPid: pid, source },
-    });
-}
-/**
- * The oldest live peer on this root, if any. The liveness rule itself lives
- * in `selectLivePeerInstances` (#2007) so warm-attach and the shared-checkout
- * guard cannot drift apart about what "another session is here" means.
- */
-export function selectWarmAttachIncumbent(entries, cwd, now = Date.now(), isPidAlive = realIsPidAlive) {
-    return selectLivePeerInstances(entries, cwd, now, isPidAlive)[0];
-}
-async function serveRequest(req) {
-    if (req.route === "code-actions") {
-        if (req.version !== WARM_DIAGNOSTICS_SCHEMA_VERSION ||
-            req.ranges.length > WARM_CODE_ACTION_LOOKUP_LIMIT ||
-            Date.now() > req.deadlineAt ||
-            state.servedDiagnosticHashes.get(normalizeFilePath(req.file)) !==
-                req.contentHash) {
-            return { error: "stale request" };
-        }
-        try {
-            const actions = await Promise.all(req.ranges.map(async (range) => {
-                if (Date.now() > req.deadlineAt) {
-                    throw new Error("deadline exceeded");
-                }
-                return (await loadLspService())
-                    .getLSPService()
-                    .codeAction(req.file, range.start.line, range.start.character, range.end.line, range.end.character);
-            }));
-            const servedAt = Date.now();
-            if (servedAt > req.deadlineAt)
-                return { error: "deadline exceeded" };
-            return {
-                result: {
-                    route: "code-actions",
-                    version: WARM_DIAGNOSTICS_SCHEMA_VERSION,
-                    contentHash: req.contentHash,
-                    servedAt,
-                    actions,
-                },
-            };
-        }
-        catch (error) {
-            return { error: String(error) };
-        }
-    }
-    if (req.route !== "diagnostics" ||
-        req.version !== WARM_DIAGNOSTICS_SCHEMA_VERSION) {
-        return { error: "schema mismatch" };
-    }
-    if (Date.now() > req.deadlineAt ||
-        contentHash(req.content) !== req.contentHash) {
-        return { error: "stale request" };
-    }
-    const touched = await (await loadLspService())
-        .getLSPService()
-        .touchFile(req.file, req.content, {
-        diagnostics: "document",
-        collectDiagnostics: true,
-        clientScope: "with-auxiliary",
-        maxClientWaitMs: Math.max(1, req.deadlineAt - Date.now()),
-        maxDiagnosticsWaitMs: Math.max(1, req.deadlineAt - Date.now()),
-        source: "warm-attach-incumbent",
-    });
-    const servedAt = Date.now();
-    // #1470: the coverage gap is read through the shared helper, never re-derived
-    // from `confirmation === "partial"`. The two fields are set together today, so
-    // either test passes — which is exactly the coincidence `touchCoverageGap`'s
-    // own doc comment warns against. One reader, one rule.
-    const coverageGap = touchCoverageGap(touched);
-    if (servedAt <= req.deadlineAt &&
-        touched !== undefined &&
-        !touched.inconclusive) {
-        state.servedDiagnosticHashes.set(normalizeFilePath(req.file), req.contentHash);
-    }
-    return {
-        result: {
-            route: "diagnostics",
-            version: WARM_DIAGNOSTICS_SCHEMA_VERSION,
-            // #1179: `touchFile` now returns the `{ diags, inconclusive, binding }`
-            // wrapper — take the array off `.diags`. This is the canonical shape-5
-            // serialization boundary: the diagnostics array crosses the IPC socket
-            // and `inconclusive` is re-surfaced below as an EXPLICIT enumerable DTO
-            // field (no side-channel survives `JSON.stringify`).
-            diagnostics: touched?.diags ?? [],
-            contentHash: req.contentHash,
-            servedAt,
-            fresh: servedAt <= req.deadlineAt && touched !== undefined,
-            inconclusive: touched?.inconclusive === true,
-            // #1253: carry the touch's own confirmation verdict across the socket
-            // as an explicit enumerable field (same doctrine as `inconclusive`) —
-            // without it, an incumbent-served empty result from a silent-on-clean
-            // server is indistinguishable from "never answered" on the far side.
-            ...(touched?.confirmation === "confirmed"
-                ? { confirmation: "confirmed" }
-                : {}),
-            // #1470: a PARTIAL touch crosses the socket as itself rather than as a
-            // missing key. Omitting it would still fail closed on the far side, but it
-            // would be indistinguishable from an old incumbent that never sent the
-            // field — and the whole point of narrowing is that the reader can tell
-            // which coverage is real.
-            ...(coverageGap.length > 0
-                ? {
-                    confirmation: "partial",
-                    unconfirmedServerIds: [...coverageGap],
-                }
-                : {}),
-        },
-    };
-}
-function startServer(cwd) {
-    state.server?.close();
-    const endpoint = diagnosticsIpcPathForCwd(cwd, process.pid);
-    if (process.platform !== "win32") {
-        try {
-            fs.unlinkSync(endpoint);
-        }
-        catch {
-            // No stale socket.
-        }
-    }
-    const server = net.createServer((socket) => {
-        socket.setEncoding("utf8");
-        // One-shot per connection (#1219 family): the same defect shape as the
-        // MCP warm socket — clients write exactly one request and read one
-        // reply, so a handler that kept re-reading the same buffered line
-        // re-dispatched the request on stray bytes. The shared reader consumes
-        // the line and ignores anything after it.
-        socket.on("data", createWarmIpcLineReader((line) => {
-            void (async () => {
-                try {
-                    const req = JSON.parse(line);
-                    socket.end(`${JSON.stringify(await serveRequest(req))}\n`);
-                }
-                catch (error) {
-                    socket.end(`${JSON.stringify({ error: String(error) })}\n`);
-                }
-            })();
-        }));
-    });
-    server.on("error", (error) => {
-        record("listener-error", cwd, String(error));
-    });
-    server.listen(endpoint);
-    server.unref();
-    state.server = server;
-}
-export async function configureWarmAttach(cwd) {
-    state.cwd = path.resolve(cwd);
-    state.incumbentPid = undefined;
-    state.local = true;
-    if (process.env.PI_LENS_WARM_ATTACH !== "1") {
-        record("disabled", state.cwd, "opt-in-not-enabled");
-        return;
-    }
-    startServer(state.cwd);
-    const incumbent = selectWarmAttachIncumbent(await readInstanceRegistry(), state.cwd);
-    if (!incumbent) {
-        record("local", state.cwd, "no-live-incumbent");
-        return;
-    }
-    state.incumbentPid = incumbent.pid;
-    state.local = false;
-    record("attached", state.cwd, undefined, incumbent.pid);
-}
-export async function tryWarmAttachedDiagnostics(file, content, timeoutMs, source = "per-edit") {
-    if (state.local || !state.cwd || !state.incumbentPid)
-        return undefined;
-    const entries = await readInstanceRegistry();
-    const incumbent = selectWarmAttachIncumbent(entries, state.cwd);
-    if (incumbent?.pid !== state.incumbentPid) {
-        promoteToLocal("incumbent-stale-or-exited");
-        return undefined;
-    }
-    const result = await requestWarmDiagnostics(state.cwd, state.incumbentPid, file, content, timeoutMs);
-    if (!result.available) {
-        promoteToLocal(result.reason);
-    }
-    else {
-        record("diagnostics-served", file, undefined, state.incumbentPid, source);
-    }
-    return result;
-}
-export async function tryWarmAttachedCodeActions(file, expectedContentHash, ranges, timeoutMs) {
-    if (state.local || !state.cwd || !state.incumbentPid)
-        return undefined;
-    const result = await requestWarmCodeActions(state.cwd, state.incumbentPid, file, expectedContentHash, ranges, timeoutMs);
-    if (result.available) {
-        record("code-actions-served", file, undefined, state.incumbentPid);
-    }
-    else {
-        // Quickfixes are optional enrichment. Diagnostics already succeeded, so a
-        // code-action failure is deliberately softer and must not trigger takeover.
-        record("code-actions-skipped", file, result.reason, state.incumbentPid);
-    }
-    return result;
-}
-export function isWarmAttached() {
-    return !state.local && state.incumbentPid !== undefined;
-}
-function promoteToLocal(reason) {
-    if (state.local)
-        return;
-    const pid = state.incumbentPid;
-    state.local = true;
-    state.incumbentPid = undefined;
-    record("takeover", state.cwd ?? process.cwd(), reason, pid);
-}
-export function _resetWarmAttachForTests() {
-    state.server?.close();
-    state.server = undefined;
-    state.cwd = undefined;
-    state.incumbentPid = undefined;
-    state.local = true;
-    state.servedDiagnosticHashes.clear();
-}
-export function _setWarmAttachForTests(cwd, incumbentPid) {
-    state.cwd = path.resolve(cwd);
-    state.incumbentPid = incumbentPid;
-    state.local = false;
-}
-/**
- * The incumbent-side request handler, exposed for tests. The socket wiring
- * around it (`startServer`) can only be exercised by a test that actually
- * binds a unix socket, which is not available in every sandbox — this seam
- * lets the DTO-composition half (notably the #1253 `confirmation` field, whose
- * absence is what a consumer reads as unconfirmed) be pinned directly.
- */
-export const _serveWarmRequestForTests = serveRequest;