pi-lens 3.8.70 → 3.8.71

package/dist/clients/file-utils.js

@@ -5,8 +5,9 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { minimatch } from "./deps/minimatch.js";
+import { collectTrackedFiles, getTrackedFilesSnapshot } from "./git-tracked-ignore.js";
 import { getGlobalIgnorePatterns, getPiLensGlobalConfigPath, } from "./lens-config.js";
-import { normalizeFilePath } from "./path-utils.js";
+import { normalizeEphemeralMapKey, normalizeFilePath } from "./path-utils.js";
 import { findPiLensProjectConfig, loadPiLensProjectConfig, } from "./project-lens-config.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 /**
@@ -167,7 +168,7 @@ function stripTrailingSpaces(value) {
         end -= 1;
     return value.slice(0, end).replace(/\\ /g, " ");
 }
-function parseGitignoreContent(content) {
+function parseGitignoreContent(content, layer) {
     const patterns = [];
     for (const rawLine of content.split(/\r?\n/)) {
         let line = stripTrailingSpaces(rawLine.trimStart());
@@ -195,6 +196,7 @@ function parseGitignoreContent(content) {
             directoryOnly,
             rooted,
             hasSlash: line.includes("/"),
+            layer,
         });
     }
     return patterns;
@@ -225,10 +227,10 @@ function matchesGitignorePattern(pattern, relativePath, isDirectory) {
         return candidates.some((value) => minimatch(value, expanded, options));
     });
 }
-export function readGitignorePatterns(rootDir) {
+export function readGitignorePatterns(rootDir, layer = "gitignore") {
     const gitignorePath = path.join(rootDir, ".gitignore");
     try {
-        return parseGitignoreContent(fs.readFileSync(gitignorePath, "utf-8"));
+        return parseGitignoreContent(fs.readFileSync(gitignorePath, "utf-8"), layer);
     }
     catch {
         return [];
@@ -264,7 +266,7 @@ function buildProjectIgnoreMatcher(resolvedRoot, patterns) {
         });
         return nextPatterns;
     };
-    // Per-matcher path → boolean memo. The matcher itself is cached by
+    // Per-matcher path → pattern-verdict memo. The matcher itself is cached by
     // `getProjectIgnoreMatcher` keyed on `.gitignore` mtime, so this Map's
     // lifetime is bounded to a single set of ignore rules — when any
     // `.gitignore` changes, the matcher is rebuilt and the memo is dropped
@@ -272,41 +274,97 @@ function buildProjectIgnoreMatcher(resolvedRoot, patterns) {
     // jscpd, call-graph, source-filter, pipeline) recomputes O(ancestorDirs ×
     // patterns) per file, multiplying into 2-3s of pure CPU on a 2k-file
     // project. With it, the second visitor of the same path is O(1).
-    const isIgnoredMemo = new Map();
+    //
+    // #703: this memoizes only the PATTERN verdict (which is deterministic —
+    // it never changes for a given matcher instance), NOT the tracked-aware
+    // final verdict. The tracked-files set can transition from "not yet
+    // primed" to "primed" mid-process (a walker calls `ensureTrackedIndex()`
+    // partway through the matcher's lifetime), so baking the tracked check
+    // into this memo would let an early, pre-priming call poison every later
+    // lookup of the same path for this matcher's entire cache lifetime. The
+    // tracked-set lookup itself is a cheap Set#has over syntactically-folded
+    // keys (see `isTrackedAndRescued` — no `realpathSync` anywhere in this
+    // function), and — critically — it's only ever paid for paths a pattern
+    // already flagged as ignored, so it doesn't reintroduce the per-file cost
+    // this memo exists to avoid for the common (not-ignored) case.
+    const patternMemo = new Map();
+    // #703 perf follow-up: `normalizeEphemeralMapKey` (cheap slash-fold +
+    // Windows-lowercase, zero fs I/O), NOT `normalizeMapKey` (realpath-backed).
+    // This runs on every `isIgnored` call that reaches this branch — walks
+    // over this repo alone visit thousands of pattern-ignored compiled
+    // `*.js`/`*.d.ts` files, and `dispatch/integration.ts`'s per-edit cascade
+    // check hits it too — so a `realpathSync` here would violate the
+    // event-loop/slow-FS discipline `isIgnored` is required to keep (#462: 75x
+    // slower on 9p/drvfs). Both `resolved` (this matcher's own `path.resolve`,
+    // never realpath'd) and the tracked-set's keys (`git-tracked-ignore.ts`,
+    // realpath'd ONCE per fetch on the shared root, not per file) are
+    // self-consistent within one process/session, which is exactly
+    // `normalizeEphemeralMapKey`'s contract — see that function's doc and
+    // `git-tracked-ignore.ts`'s module doc for the full reasoning. Accepted
+    // edge case: a symlinked or 8.3-short-name project root can make the cheap
+    // fold miss even after the fetch side's one realpath — the file then stays
+    // pattern-ignored, i.e. degrades to today's (pre-#703) behavior, which is
+    // consistent with this whole feature's fail-open contract.
+    function isTrackedAndRescued(resolved) {
+        const snapshot = getTrackedFilesSnapshot(resolvedRoot);
+        if (!snapshot)
+            return false; // never primed / git unavailable: fail-open to pattern-only
+        return snapshot.has(normalizeEphemeralMapKey(resolved));
+    }
     return {
         rootDir: resolvedRoot,
         patterns,
+        ensureTrackedIndex() {
+            return collectTrackedFiles(resolvedRoot).then(() => undefined);
+        },
         isIgnored(filePath, isDirectory = false) {
             const resolved = path.resolve(filePath);
             // Two namespaces (D: for directory queries, F: for file queries)
             // because gitignore semantics differ for trailing-slash patterns.
             const memoKey = (isDirectory ? "D:" : "F:") + resolved;
-            const cached = isIgnoredMemo.get(memoKey);
-            if (cached !== undefined)
-                return cached;
-            const rootRelative = path.relative(resolvedRoot, resolved);
-            if (!rootRelative ||
-                rootRelative.startsWith("..") ||
-                path.isAbsolute(rootRelative)) {
-                isIgnoredMemo.set(memoKey, false);
-                return false;
-            }
-            let ignored = false;
-            const patternDirs = ancestorDirsBetween(resolvedRoot, path.dirname(resolved));
-            for (const dir of patternDirs) {
-                const dirPatterns = patternsForDir(dir);
-                if (dirPatterns.length === 0)
-                    continue;
-                const relative = path.relative(dir, resolved);
-                const normalized = normalizeIgnorePath(relative);
-                for (const pattern of dirPatterns) {
-                    if (!matchesGitignorePattern(pattern, normalized, isDirectory))
-                        continue;
-                    ignored = !pattern.negated;
+            let verdict = patternMemo.get(memoKey);
+            if (verdict === undefined) {
+                const rootRelative = path.relative(resolvedRoot, resolved);
+                if (!rootRelative ||
+                    rootRelative.startsWith("..") ||
+                    path.isAbsolute(rootRelative)) {
+                    verdict = { ignored: false, layer: undefined };
+                }
+                else {
+                    let ignored = false;
+                    let layer;
+                    const patternDirs = ancestorDirsBetween(resolvedRoot, path.dirname(resolved));
+                    for (const dir of patternDirs) {
+                        const dirPatterns = patternsForDir(dir);
+                        if (dirPatterns.length === 0)
+                            continue;
+                        const relative = path.relative(dir, resolved);
+                        const normalized = normalizeIgnorePath(relative);
+                        for (const pattern of dirPatterns) {
+                            if (!matchesGitignorePattern(pattern, normalized, isDirectory))
+                                continue;
+                            ignored = !pattern.negated;
+                            layer = pattern.layer;
+                        }
+                    }
+                    verdict = { ignored, layer };
                 }
+                patternMemo.set(memoKey, verdict);
             }
-            isIgnoredMemo.set(memoKey, ignored);
-            return ignored;
+            if (!verdict.ignored)
+                return false;
+            // #703 layer semantics: a winning positive match from `global` or
+            // `gitignore` emulates git, so it inherits git's "a tracked file is
+            // never ignored" rule. A winning match from `pilens` is pi-lens-native
+            // intent and stays excluded regardless of tracked status. Directory
+            // queries are never tracked-rescued — the tracked set is a file-id
+            // set, not a directory set.
+            if (!isDirectory &&
+                verdict.layer !== "pilens" &&
+                isTrackedAndRescued(resolved)) {
+                return false;
+            }
+            return true;
         },
     };
 }
@@ -315,10 +373,13 @@ export function createProjectIgnoreMatcher(rootDir, extraPatterns = [], globalPa
     // Precedence is gitignore order: LATER patterns override earlier ones. So
     // global (lowest) → project .gitignore → project .pi-lens.json (highest),
     // which lets a project `!negation` re-include a globally-ignored path (#252).
+    // Each layer is tagged (#703) so `isIgnored` can tell a git-emulating match
+    // (`global`/`gitignore` — subject to "a tracked file is never ignored")
+    // apart from pi-lens-native intent (`pilens` — excludes regardless).
     const patterns = [
-        ...parseGitignoreContent(globalPatterns.join("\n")),
-        ...readGitignorePatterns(resolvedRoot),
-        ...parseGitignoreContent(extraPatterns.join("\n")),
+        ...parseGitignoreContent(globalPatterns.join("\n"), "global"),
+        ...readGitignorePatterns(resolvedRoot, "gitignore"),
+        ...parseGitignoreContent(extraPatterns.join("\n"), "pilens"),
     ];
     return buildProjectIgnoreMatcher(resolvedRoot, patterns);
 }

package/dist/clients/format-events-publish.js

@@ -0,0 +1,299 @@
+/**
+ * Publishes `pilens:format:queued`, `pilens:format:start`, and
+ * `pilens:autofix:start` on pi's shared `pi.events` bus (#673, #684).
+ *
+ * Sibling to `clients/bus-publish.ts` (#482 `pilens:files:touched`) and
+ * `clients/diagnostics-publish.ts` (#502 `pilens:diagnostics`) rather than a
+ * new export crammed into either file: same emit plumbing shape and the same
+ * `PI_LENS_BUS_PUBLISH` kill switch (`isBusPublishEnabled`, imported from
+ * bus-publish.ts), but this producer owns its own emit-function singleton
+ * (wired separately from index.ts, same as diagnostics-publish.ts does) since
+ * it has nothing else in common with either sibling's module state.
+ *
+ * ## Motivation (#673)
+ *
+ * `pilens:files:touched` only fires AFTER deferred formatting has completed —
+ * it tells a same-process listener what pi-lens just mutated, in the past
+ * tense. #673 reported a concrete failure mode this leaves uncovered: another
+ * in-process extension (a review/snapshot controller) derives an immutable
+ * candidate tree from the live worktree mid-turn, unaware that pi-lens has a
+ * file queued for deferred formatting that will still land — silently
+ * invalidating the snapshot it just took. There was no bus signal for either
+ * of the two moments that matter to that use case:
+ *
+ *   1. A file NEWLY entering the deferred-format pending queue
+ *      (`pilens:format:queued` — one event per file, only on first queue
+ *      entry; a file re-touched by a second edit before `agent_end` does NOT
+ *      re-emit, to avoid event spam for repeated edits to the same file).
+ *   2. The deferred-format phase actually starting at `agent_end`
+ *      (`pilens:format:start` — one event per batch, only when there is at
+ *      least one queued file to format).
+ *
+ * This is deliberately visibility-only: it lets a listener know pi-lens MIGHT
+ * or IS ABOUT TO mutate specific files via deferred formatting, so it can
+ * choose to wait, re-derive, or flag its own snapshot as provisional. It is
+ * NOT a synchronous flush/barrier API (a caller cannot block deferred
+ * formatting via these events) — that remains a separate, explicitly
+ * out-of-scope future feature. Completion is already covered by the existing
+ * `pilens:files:touched` (`reason: "format"`) event; these two do not
+ * duplicate it.
+ *
+ * ## `pilens:autofix:start` (#684)
+ *
+ * Follow-up to #673/#674, applying the identical fix to a sibling race: the
+ * `agent_end` actionable-warnings autofix batch (`clients/runtime-agent-end.ts`,
+ * gated by `getFlag("lens-actionable-warning-autofix")`) also reads a cached
+ * report and applies fixes as a batch well after the edit that produced the
+ * warnings — same "runs later, unpredictably" shape as deferred formatting.
+ * It only emitted `pilens:files:touched` (`reason: "autofix"`) AFTER the fact.
+ * `pilens:autofix:start` fires once per batch, only when the cached
+ * actionable-warnings report is fresh (`checkActionableWarningsReportFresh`)
+ * AND has at least one autofix-eligible warning to act on — mirroring
+ * `pilens:format:start`'s "only when there's genuine work" gate. Note: this is
+ * distinct from `pipeline.ts`'s per-edit `runAutofix` (biome/ruff/eslint fixes
+ * applied synchronously inside the `tool_result` hook, awaited before the
+ * tool result returns) — that path isn't deferred and doesn't have this race,
+ * so it doesn't get a `start` event.
+ *
+ * Versioning policy: frozen-additive per event, same discipline as #482/#502.
+ * New optional fields may be added under the same `v: 1` for any of the three
+ * events; a breaking change to an existing field's meaning must bump that
+ * event's `v` independently (each event versions separately since they're
+ * unrelated payloads).
+ *
+ * Fire-and-forget: publishing must never affect the write path's or
+ * `agent_end`'s success or latency. Any failure (bus unavailable, emit
+ * throws) is swallowed; an optional `dbg` callback is invoked at most once
+ * per event type on first failure so a wired caller can log it without
+ * spamming.
+ */
+import { logBusEvent } from "./bus-events-logger.js";
+import { isBusPublishEnabled } from "./bus-publish.js";
+import { normalizeFilePath } from "./path-utils.js";
+export const BUS_FORMAT_QUEUED_EVENT = "pilens:format:queued";
+export const BUS_FORMAT_QUEUED_VERSION = 1;
+export const BUS_FORMAT_START_EVENT = "pilens:format:start";
+export const BUS_FORMAT_START_VERSION = 1;
+export const BUS_AUTOFIX_START_EVENT = "pilens:autofix:start";
+export const BUS_AUTOFIX_START_VERSION = 1;
+let busEmit;
+let hasLoggedQueuedFailure = false;
+let hasLoggedQueuedUnwired = false;
+let hasLoggedQueuedDisabled = false;
+let hasLoggedStartFailure = false;
+let hasLoggedStartUnwired = false;
+let hasLoggedStartDisabled = false;
+let hasLoggedAutofixStartFailure = false;
+let hasLoggedAutofixStartUnwired = false;
+let hasLoggedAutofixStartDisabled = false;
+/**
+ * Wire the emit function from pi's `pi.events` bus. Called once at extension
+ * factory time from index.ts, alongside `wireBusEmitter` (#482) and
+ * `wireDiagnosticsBusEmitter` (#502) — all three producers share the
+ * identical `pi.events.emit` binding, wired separately per producer.
+ */
+export function wireFormatEventsBusEmitter(emitFn) {
+    busEmit = emitFn;
+}
+/** Test-only: reset module state between test files. */
+export function _resetFormatEventsPublishForTests() {
+    busEmit = undefined;
+    hasLoggedQueuedFailure = false;
+    hasLoggedQueuedUnwired = false;
+    hasLoggedQueuedDisabled = false;
+    hasLoggedStartFailure = false;
+    hasLoggedStartUnwired = false;
+    hasLoggedStartDisabled = false;
+    hasLoggedAutofixStartFailure = false;
+    hasLoggedAutofixStartUnwired = false;
+    hasLoggedAutofixStartDisabled = false;
+}
+/**
+ * Publish one `pilens:format:queued` event for a file newly entering the
+ * deferred-format pending queue. Callers MUST only invoke this on the
+ * NEW-entry branch of `RuntimeCoordinator.deferFormat` (not on a re-touch of
+ * an already-queued file) — see `clients/runtime-tool-result.ts`'s call site.
+ * Fire-and-forget: never throws, never awaited by the write path.
+ */
+export function publishFormatQueued(args) {
+    if (!isBusPublishEnabled()) {
+        if (!hasLoggedQueuedDisabled) {
+            hasLoggedQueuedDisabled = true;
+            logBusEvent({
+                event: BUS_FORMAT_QUEUED_EVENT,
+                outcome: "skipped_disabled",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    if (!busEmit) {
+        if (!hasLoggedQueuedUnwired) {
+            hasLoggedQueuedUnwired = true;
+            logBusEvent({
+                event: BUS_FORMAT_QUEUED_EVENT,
+                outcome: "skipped_unwired",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    try {
+        const payload = {
+            v: BUS_FORMAT_QUEUED_VERSION,
+            source: "pi-lens",
+            filePath: normalizeFilePath(args.filePath),
+            cwd: normalizeFilePath(args.cwd),
+            tool: args.tool,
+        };
+        busEmit(BUS_FORMAT_QUEUED_EVENT, payload);
+        logBusEvent({
+            event: BUS_FORMAT_QUEUED_EVENT,
+            outcome: "emitted",
+            cwd: payload.cwd,
+            fileCount: 1,
+        });
+    }
+    catch (err) {
+        logBusEvent({
+            event: BUS_FORMAT_QUEUED_EVENT,
+            outcome: "emit_failed",
+            cwd: normalizeFilePath(args.cwd),
+            error: String(err),
+        });
+        if (!hasLoggedQueuedFailure) {
+            hasLoggedQueuedFailure = true;
+            args.dbg?.(`format-events-publish: pilens:format:queued emit failed (further failures suppressed): ${err}`);
+        }
+    }
+}
+/**
+ * Publish one `pilens:format:start` event when the `agent_end` deferred-
+ * format phase begins. Callers MUST only invoke this when `paths.length > 0`
+ * — see `clients/runtime-agent-end.ts`'s call site, placed at the same point
+ * as the existing `agent_end_deferred_format_start` latency-log phase so both
+ * signals represent the identical moment. Fire-and-forget: never throws,
+ * never awaited by `agent_end`.
+ */
+export function publishFormatStart(args) {
+    if (args.paths.length === 0)
+        return;
+    if (!isBusPublishEnabled()) {
+        if (!hasLoggedStartDisabled) {
+            hasLoggedStartDisabled = true;
+            logBusEvent({
+                event: BUS_FORMAT_START_EVENT,
+                outcome: "skipped_disabled",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    if (!busEmit) {
+        if (!hasLoggedStartUnwired) {
+            hasLoggedStartUnwired = true;
+            logBusEvent({
+                event: BUS_FORMAT_START_EVENT,
+                outcome: "skipped_unwired",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    try {
+        const paths = args.paths.map((p) => normalizeFilePath(p));
+        const payload = {
+            v: BUS_FORMAT_START_VERSION,
+            source: "pi-lens",
+            cwd: normalizeFilePath(args.cwd),
+            paths,
+            fileCount: paths.length,
+        };
+        busEmit(BUS_FORMAT_START_EVENT, payload);
+        logBusEvent({
+            event: BUS_FORMAT_START_EVENT,
+            outcome: "emitted",
+            cwd: payload.cwd,
+            fileCount: payload.fileCount,
+        });
+    }
+    catch (err) {
+        logBusEvent({
+            event: BUS_FORMAT_START_EVENT,
+            outcome: "emit_failed",
+            cwd: normalizeFilePath(args.cwd),
+            error: String(err),
+        });
+        if (!hasLoggedStartFailure) {
+            hasLoggedStartFailure = true;
+            args.dbg?.(`format-events-publish: pilens:format:start emit failed (further failures suppressed): ${err}`);
+        }
+    }
+}
+/**
+ * Publish one `pilens:autofix:start` event when the `agent_end`
+ * actionable-warnings autofix batch begins (#684). Callers MUST only invoke
+ * this when `paths.length > 0` — i.e. after the cached report has been
+ * confirmed fresh (`checkActionableWarningsReportFresh`) AND has at least one
+ * autofix-eligible warning to act on, the same "genuine work" gate
+ * `publishFormatStart` applies for deferred formatting — see
+ * `clients/runtime-agent-end.ts`'s call site, placed immediately before
+ * `applyConservativeActionableWarningFixes` is invoked. Fire-and-forget:
+ * never throws, never awaited by `agent_end`.
+ */
+export function publishAutofixStart(args) {
+    if (args.paths.length === 0)
+        return;
+    if (!isBusPublishEnabled()) {
+        if (!hasLoggedAutofixStartDisabled) {
+            hasLoggedAutofixStartDisabled = true;
+            logBusEvent({
+                event: BUS_AUTOFIX_START_EVENT,
+                outcome: "skipped_disabled",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    if (!busEmit) {
+        if (!hasLoggedAutofixStartUnwired) {
+            hasLoggedAutofixStartUnwired = true;
+            logBusEvent({
+                event: BUS_AUTOFIX_START_EVENT,
+                outcome: "skipped_unwired",
+                cwd: normalizeFilePath(args.cwd),
+            });
+        }
+        return;
+    }
+    try {
+        const paths = args.paths.map((p) => normalizeFilePath(p));
+        const payload = {
+            v: BUS_AUTOFIX_START_VERSION,
+            source: "pi-lens",
+            cwd: normalizeFilePath(args.cwd),
+            paths,
+            fileCount: paths.length,
+            eligibleCount: args.eligibleCount,
+        };
+        busEmit(BUS_AUTOFIX_START_EVENT, payload);
+        logBusEvent({
+            event: BUS_AUTOFIX_START_EVENT,
+            outcome: "emitted",
+            cwd: payload.cwd,
+            fileCount: payload.fileCount,
+        });
+    }
+    catch (err) {
+        logBusEvent({
+            event: BUS_AUTOFIX_START_EVENT,
+            outcome: "emit_failed",
+            cwd: normalizeFilePath(args.cwd),
+            error: String(err),
+        });
+        if (!hasLoggedAutofixStartFailure) {
+            hasLoggedAutofixStartFailure = true;
+            args.dbg?.(`format-events-publish: pilens:autofix:start emit failed (further failures suppressed): ${err}`);
+        }
+    }
+}