@herbertgao/pi-extensions 2026.8.4 → 2026.8.6

package/node_modules/pi-lens/dist/clients/file-utils.js

@@ -265,11 +265,19 @@ function buildProjectIgnoreMatcher(resolvedRoot, patterns) {
     const patternsForDir = (dir) => {
         if (dir === resolvedRoot)
             return patterns;
-        const gitignoreMtime = gitignoreMtimeMs(dir);
-        const pilensMtime = findPiLensConfigInDir(dir)?.mtimeMs ?? -1;
+        const gitignoreSig = gitignoreSignature(dir);
+        // #1105: gate on size too. `findPiLensConfigInDir` returns `size` alongside
+        // `mtimeMs` (both from one stat), and `gitignoreSignature` reads both for
+        // the nested `.gitignore`, so an mtime-preserving, length-changing edit to
+        // EITHER nested source can no longer replay stale patterns for this subtree.
+        const pilensInfo = findPiLensConfigInDir(dir);
+        const pilensMtime = pilensInfo?.mtimeMs ?? -1;
+        const pilensSize = pilensInfo?.size ?? -1;
         const cached = nestedCache.get(dir);
-        if (cached?.gitignoreMtimeMs === gitignoreMtime &&
-            cached?.pilensMtimeMs === pilensMtime) {
+        if (cached?.gitignoreMtimeMs === gitignoreSig.mtimeMs &&
+            cached?.gitignoreSize === gitignoreSig.size &&
+            cached?.pilensMtimeMs === pilensMtime &&
+            cached?.pilensSize === pilensSize) {
             return cached.patterns;
         }
         const nestedConfig = loadPiLensConfigInDir(dir);
@@ -278,15 +286,17 @@ function buildProjectIgnoreMatcher(resolvedRoot, patterns) {
             ...parseGitignoreContent(nestedConfig.ignore.join("\n"), "pilens"),
         ];
         nestedCache.set(dir, {
-            gitignoreMtimeMs: gitignoreMtime,
+            gitignoreMtimeMs: gitignoreSig.mtimeMs,
+            gitignoreSize: gitignoreSig.size,
             pilensMtimeMs: pilensMtime,
+            pilensSize: pilensSize,
             patterns: nextPatterns,
         });
         return nextPatterns;
     };
     // 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
+    // `getProjectIgnoreMatcher` keyed on `.gitignore` size+mtime (#1105), 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
     // with it. Without this memo, every background scan (comment scan, knip,
     // jscpd, call-graph, source-filter, pipeline) recomputes O(ancestorDirs ×
@@ -402,26 +412,20 @@ export function createProjectIgnoreMatcher(rootDir, extraPatterns = [], globalPa
     return buildProjectIgnoreMatcher(resolvedRoot, patterns);
 }
 const projectIgnoreMatcherCache = new Map();
-/**
- * mtime of the global `~/.pi-lens/config.json` (or the PI_LENS_CONFIG_PATH
- * override). Part of the ignore-matcher cache key so editing global ignore
- * patterns takes effect without a restart (#252). -1 when absent.
- */
-function globalConfigMtimeMs() {
+function fileFreshnessSignature(filePath) {
     try {
-        return fs.statSync(getPiLensGlobalConfigPath()).mtimeMs;
+        const stat = fs.statSync(filePath);
+        return { mtimeMs: stat.mtimeMs, size: stat.size };
     }
     catch {
-        return -1;
+        return { mtimeMs: -1, size: -1 };
     }
 }
-function gitignoreMtimeMs(rootDir) {
-    try {
-        return fs.statSync(path.join(rootDir, ".gitignore")).mtimeMs;
-    }
-    catch {
-        return -1;
-    }
+function globalConfigSignature() {
+    return fileFreshnessSignature(getPiLensGlobalConfigPath());
+}
+function gitignoreSignature(rootDir) {
+    return fileFreshnessSignature(path.join(rootDir, ".gitignore"));
 }
 /**
  * The project config file found by the same upward walk as the loader. Cache
@@ -432,32 +436,39 @@ function gitignoreMtimeMs(rootDir) {
 function lensConfigInfo(rootDir) {
     const info = findPiLensProjectConfig(rootDir);
     return info
-        ? { info, path: info.path, mtimeMs: info.mtimeMs }
-        : { info, path: undefined, mtimeMs: -1 };
+        ? { info, path: info.path, mtimeMs: info.mtimeMs, size: info.size }
+        : { info, path: undefined, mtimeMs: -1, size: -1 };
 }
 export function getProjectIgnoreMatcher(rootDir) {
     const resolvedRoot = resolveGitIgnoreRoot(rootDir);
-    const gitignoreMtime = gitignoreMtimeMs(resolvedRoot);
+    const gitignoreSig = gitignoreSignature(resolvedRoot);
     const lensConfig = lensConfigInfo(resolvedRoot);
-    const globalMtime = globalConfigMtimeMs();
+    const globalSig = globalConfigSignature();
     const cached = projectIgnoreMatcherCache.get(resolvedRoot);
-    if (cached?.gitignoreMtimeMs === gitignoreMtime &&
+    if (cached?.gitignoreMtimeMs === gitignoreSig.mtimeMs &&
+        cached?.gitignoreSize === gitignoreSig.size &&
         cached?.lensConfigPath === lensConfig.path &&
         cached?.lensConfigMtimeMs === lensConfig.mtimeMs &&
-        cached?.globalConfigMtimeMs === globalMtime) {
+        cached?.lensConfigSize === lensConfig.size &&
+        cached?.globalConfigMtimeMs === globalSig.mtimeMs &&
+        cached?.globalConfigSize === globalSig.size) {
         return cached.matcher;
     }
     // Load both configs fresh on cache miss. On a cache HIT (the common case)
-    // none of this runs — the only per-call cost is the mtime stats above. The
-    // project loader is itself mtime-cached; the global loader re-parses, but
-    // only here on miss (when some tracked mtime changed).
+    // none of this runs — the only per-call cost is the size:mtimeMs stats above
+    // (size is free from the same stat). The project loader is itself
+    // size:mtimeMs-cached; the global loader re-parses, but only here on miss
+    // (when some tracked signature changed).
     const projectConfig = loadPiLensProjectConfig(resolvedRoot, lensConfig.info);
     const matcher = createProjectIgnoreMatcher(resolvedRoot, projectConfig.ignore, getGlobalIgnorePatterns());
     projectIgnoreMatcherCache.set(resolvedRoot, {
-        gitignoreMtimeMs: gitignoreMtime,
+        gitignoreMtimeMs: gitignoreSig.mtimeMs,
+        gitignoreSize: gitignoreSig.size,
         lensConfigPath: lensConfig.path,
         lensConfigMtimeMs: lensConfig.mtimeMs,
-        globalConfigMtimeMs: globalMtime,
+        lensConfigSize: lensConfig.size,
+        globalConfigMtimeMs: globalSig.mtimeMs,
+        globalConfigSize: globalSig.size,
         matcher,
     });
     return matcher;
@@ -465,10 +476,21 @@ export function getProjectIgnoreMatcher(rootDir) {
 export function isPathIgnoredByProject(filePath, rootDir, isDirectory = false) {
     return getProjectIgnoreMatcher(rootDir).isIgnored(filePath, isDirectory);
 }
+const projectIgnoreGlobsCache = new Map();
 export function getProjectIgnoreGlobs(rootDir) {
-    return readGitignorePatterns(rootDir)
+    const resolvedRoot = path.resolve(rootDir);
+    const signature = gitignoreSignature(resolvedRoot);
+    const cached = projectIgnoreGlobsCache.get(resolvedRoot);
+    if (cached &&
+        cached.mtimeMs === signature.mtimeMs &&
+        cached.size === signature.size) {
+        return cached.globs;
+    }
+    const globs = readGitignorePatterns(resolvedRoot)
         .filter((pattern) => !pattern.negated)
         .flatMap((pattern) => expandGitignorePattern(pattern));
+    projectIgnoreGlobsCache.set(resolvedRoot, { ...signature, globs });
+    return globs;
 }
 /**
  * Read simple directory-name entries from a root .gitignore.

package/node_modules/pi-lens/dist/clients/fix-worklog.js

@@ -18,13 +18,15 @@ export function getWorklogPath(cwd) {
  * diagnostics that were already fixed by the tool, `false` for
  * diagnostics that are fixable but require agent action.
  */
-export function appendToWorklog(cwd, diagnostics, autoFixed) {
+export function appendToWorklog(cwd, diagnostics, autoFixed, identity) {
     if (diagnostics.length === 0)
         return;
     const worklogPath = getWorklogPath(cwd);
     try {
         fs.mkdirSync(path.dirname(worklogPath), { recursive: true });
         const timestamp = new Date().toISOString();
+        const model = identity?.model?.trim() || undefined;
+        const provider = identity?.provider?.trim() || undefined;
         const lines = diagnostics
             .map((d) => {
             const entry = {
@@ -38,6 +40,8 @@ export function appendToWorklog(cwd, diagnostics, autoFixed) {
                 fixable: d.fixable ?? false,
                 fixSuggestion: d.fixSuggestion,
                 autoFixed,
+                model,
+                provider,
             };
             return JSON.stringify(entry);
         })

package/node_modules/pi-lens/dist/clients/format-events-publish.js

@@ -59,7 +59,15 @@
  * 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).
+ * unrelated payloads). `FormatQueuedPayload.kinds` (S3d, #1432 review) is now
+ * an always-present required field at `publishFormatQueued`'s call boundary —
+ * both in-repo callers already passed it, so the `?? ["format"]` fallback
+ * was fabricating data no caller asked for. This is NOT a `v` bump: `kinds`
+ * was already part of the v1 payload shape and every wire-format consumer
+ * still reads the same field; a v1 emitter built against an older copy of
+ * this module that omits `kinds` at the call site now fails to compile
+ * rather than silently emitting a guessed value, and any reader written
+ * against v1 that still treats `kinds` as possibly-absent remains correct.
  *
  * Fire-and-forget: publishing must never affect the write path's or
  * `agent_end`'s success or latency. Any failure (bus unavailable, emit
@@ -70,13 +78,14 @@
 import { logBusEvent } from "./bus-events-logger.js";
 import { isBusPublishEnabled } from "./bus-publish.js";
 import { normalizeFilePath } from "./path-utils.js";
+import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter, } from "./live-bus-emitter.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;
+const liveEmitter = createLiveBusEmitter();
 let hasLoggedQueuedFailure = false;
 let hasLoggedQueuedUnwired = false;
 let hasLoggedQueuedDisabled = false;
@@ -93,11 +102,14 @@ let hasLoggedAutofixStartDisabled = false;
  * identical `pi.events.emit` binding, wired separately per producer.
  */
 export function wireFormatEventsBusEmitter(emitFn) {
-    busEmit = emitFn;
+    liveEmitter.wire(emitFn);
+}
+export function wireFormatEventsBusEmitterGetter(getter) {
+    liveEmitter.wireGetter(getter);
 }
 /** Test-only: reset module state between test files. */
 export function _resetFormatEventsPublishForTests() {
-    busEmit = undefined;
+    liveEmitter.reset();
     hasLoggedQueuedFailure = false;
     hasLoggedQueuedUnwired = false;
     hasLoggedQueuedDisabled = false;
@@ -127,7 +139,13 @@ export function publishFormatQueued(args) {
         }
         return;
     }
-    if (!busEmit) {
+    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+        event: BUS_FORMAT_QUEUED_EVENT,
+        cwd: normalizeFilePath(args.cwd),
+    }));
+    if (resolution.outcome === "stale-session")
+        return;
+    if (resolution.outcome === "unwired") {
         if (!hasLoggedQueuedUnwired) {
             hasLoggedQueuedUnwired = true;
             logBusEvent({
@@ -138,6 +156,7 @@ export function publishFormatQueued(args) {
         }
         return;
     }
+    const busEmit = resolution.emit;
     try {
         const payload = {
             v: BUS_FORMAT_QUEUED_VERSION,
@@ -145,8 +164,10 @@ export function publishFormatQueued(args) {
             filePath: normalizeFilePath(args.filePath),
             cwd: normalizeFilePath(args.cwd),
             tool: args.tool,
+            kinds: args.kinds,
         };
         busEmit(BUS_FORMAT_QUEUED_EVENT, payload);
+        hasLoggedQueuedFailure = false;
         logBusEvent({
             event: BUS_FORMAT_QUEUED_EVENT,
             outcome: "emitted",
@@ -160,9 +181,11 @@ export function publishFormatQueued(args) {
             outcome: "emit_failed",
             cwd: normalizeFilePath(args.cwd),
             error: String(err),
+            ctxSource: resolution.ctxSource,
         });
         if (!hasLoggedQueuedFailure) {
             hasLoggedQueuedFailure = true;
+            recordStaleBusFailure(BUS_FORMAT_QUEUED_EVENT, err);
             args.dbg?.(`format-events-publish: pilens:format:queued emit failed (further failures suppressed): ${err}`);
         }
     }
@@ -189,7 +212,13 @@ export function publishFormatStart(args) {
         }
         return;
     }
-    if (!busEmit) {
+    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+        event: BUS_FORMAT_START_EVENT,
+        cwd: normalizeFilePath(args.cwd),
+    }));
+    if (resolution.outcome === "stale-session")
+        return;
+    if (resolution.outcome === "unwired") {
         if (!hasLoggedStartUnwired) {
             hasLoggedStartUnwired = true;
             logBusEvent({
@@ -200,6 +229,7 @@ export function publishFormatStart(args) {
         }
         return;
     }
+    const busEmit = resolution.emit;
     try {
         const paths = args.paths.map((p) => normalizeFilePath(p));
         const payload = {
@@ -208,8 +238,10 @@ export function publishFormatStart(args) {
             cwd: normalizeFilePath(args.cwd),
             paths,
             fileCount: paths.length,
+            kinds: args.kinds ?? ["format"],
         };
         busEmit(BUS_FORMAT_START_EVENT, payload);
+        hasLoggedStartFailure = false;
         logBusEvent({
             event: BUS_FORMAT_START_EVENT,
             outcome: "emitted",
@@ -223,9 +255,11 @@ export function publishFormatStart(args) {
             outcome: "emit_failed",
             cwd: normalizeFilePath(args.cwd),
             error: String(err),
+            ctxSource: resolution.ctxSource,
         });
         if (!hasLoggedStartFailure) {
             hasLoggedStartFailure = true;
+            recordStaleBusFailure(BUS_FORMAT_START_EVENT, err);
             args.dbg?.(`format-events-publish: pilens:format:start emit failed (further failures suppressed): ${err}`);
         }
     }
@@ -255,7 +289,13 @@ export function publishAutofixStart(args) {
         }
         return;
     }
-    if (!busEmit) {
+    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
+        event: BUS_AUTOFIX_START_EVENT,
+        cwd: normalizeFilePath(args.cwd),
+    }));
+    if (resolution.outcome === "stale-session")
+        return;
+    if (resolution.outcome === "unwired") {
         if (!hasLoggedAutofixStartUnwired) {
             hasLoggedAutofixStartUnwired = true;
             logBusEvent({
@@ -266,6 +306,7 @@ export function publishAutofixStart(args) {
         }
         return;
     }
+    const busEmit = resolution.emit;
     try {
         const paths = args.paths.map((p) => normalizeFilePath(p));
         const payload = {
@@ -277,6 +318,7 @@ export function publishAutofixStart(args) {
             eligibleCount: args.eligibleCount,
         };
         busEmit(BUS_AUTOFIX_START_EVENT, payload);
+        hasLoggedAutofixStartFailure = false;
         logBusEvent({
             event: BUS_AUTOFIX_START_EVENT,
             outcome: "emitted",
@@ -290,9 +332,11 @@ export function publishAutofixStart(args) {
             outcome: "emit_failed",
             cwd: normalizeFilePath(args.cwd),
             error: String(err),
+            ctxSource: resolution.ctxSource,
         });
         if (!hasLoggedAutofixStartFailure) {
             hasLoggedAutofixStartFailure = true;
+            recordStaleBusFailure(BUS_AUTOFIX_START_EVENT, err);
             args.dbg?.(`format-events-publish: pilens:autofix:start emit failed (further failures suppressed): ${err}`);
         }
     }

package/node_modules/pi-lens/dist/clients/format-service.js

@@ -10,10 +10,11 @@
  * - FileTime integration for safety
  * - Explicit config wins; otherwise smart defaults apply
  */
+import { logExtension } from "./extension-log.js";
 import * as path from "node:path";
 import { recordFormatter } from "./widget-state.js";
 import { FileTime } from "./file-time.js";
-import { clearFormatterRuntimeState, formatFile, getFormattersForFile, } from "./formatters.js";
+import { loadFormatters } from "./formatters-lazy.js";
 // --- Configuration ---
 /** Reserved for future batching; formatting currently runs one selected formatter per file. */
 const DEFAULT_FORMATTER_CONCURRENCY = 1;
@@ -42,7 +43,12 @@ export class FormatService {
         }
         // Check if file was modified externally (safety check)
         if (this.fileTime.hasChanged(absolutePath)) {
-            console.warn(`[format] File ${absolutePath} modified externally, skipping format`);
+            logExtension({
+                subsystem: "format",
+                level: "warn",
+                message: `File ${absolutePath} modified externally, skipping format`,
+                metadata: { filePath: absolutePath },
+            });
             return {
                 filePath: absolutePath,
                 formatters: [],
@@ -53,7 +59,7 @@ export class FormatService {
         // Get formatters for this file
         const formatters = options.formatters
             ? await this.getFormattersByName(options.formatters)
-            : await getFormattersForFile(absolutePath, cwd);
+            : await (await loadFormatters()).getFormattersForFile(absolutePath, cwd);
         if (formatters.length === 0) {
             return {
                 filePath: absolutePath,
@@ -90,13 +96,19 @@ export class FormatService {
     async runFormattersWithConcurrency(filePath, formatters, _concurrency = DEFAULT_FORMATTER_CONCURRENCY) {
         const results = [];
         for (const formatter of formatters) {
+            // #1097: keep the timer handle so it can be cleared once the race
+            // settles. An uncleared, REF'D 30s setTimeout that outlives a fast
+            // `formatFile` win would keep a one-shot `pi --print` process alive for
+            // up to 30s after completion (same uncleared-race-timeout class as the
+            // LSP client-wait leak fixed in clients/lsp/index.ts).
+            let formatTimer;
             try {
                 const timeoutMs = 30000;
                 const timeoutPromise = new Promise((_, reject) => {
-                    setTimeout(() => reject(new Error(`Formatter ${formatter.name} timed out after ${timeoutMs}ms`)), timeoutMs);
+                    formatTimer = setTimeout(() => reject(new Error(`Formatter ${formatter.name} timed out after ${timeoutMs}ms`)), timeoutMs);
                 });
                 const result = await Promise.race([
-                    formatFile(filePath, formatter),
+                    loadFormatters().then(({ formatFile }) => formatFile(filePath, formatter)),
                     timeoutPromise,
                 ]);
                 results.push(result);
@@ -108,6 +120,10 @@ export class FormatService {
                     error: error instanceof Error ? error.message : String(error),
                 });
             }
+            finally {
+                if (formatTimer)
+                    clearTimeout(formatTimer);
+            }
         }
         return results;
     }
@@ -115,7 +131,7 @@ export class FormatService {
      * Get formatters by name (for explicit formatter selection)
      */
     async getFormattersByName(names) {
-        const { listAllFormatters, ...formatters } = await import("./formatters.js");
+        const { listAllFormatters, ...formatters } = await loadFormatters();
         const allNames = listAllFormatters();
         return names
             .filter((name) => allNames.includes(name))
@@ -151,7 +167,7 @@ export class FormatService {
      * Clear detection cache
      */
     clearCache() {
-        clearFormatterRuntimeState();
+        void loadFormatters().then(({ clearFormatterRuntimeState }) => clearFormatterRuntimeState());
     }
 }
 // --- Singleton Instance ---
@@ -169,7 +185,7 @@ export function getFormatService(sessionID, enabled = true) {
     return globalFormatService;
 }
 export function resetFormatService() {
-    clearFormatterRuntimeState();
+    void loadFormatters().then(({ clearFormatterRuntimeState }) => clearFormatterRuntimeState());
     globalFormatService = null;
     currentSessionID = null;
 }

package/node_modules/pi-lens/dist/clients/formatters-lazy.js

@@ -0,0 +1,8 @@
+/** Shared lazy formatter catalog seam (#1394). */
+let formatterPromise;
+export function warmFormatters() {
+    return (formatterPromise ??= import("./formatters.js"));
+}
+export function loadFormatters() {
+    return warmFormatters();
+}