@herbertgao/pi-extensions 2026.10.1 → 2026.10.3

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

@@ -1,103 +0,0 @@
-/**
- * Fix Worklog for pi-lens
- *
- * Appends auto-fixed and fixable diagnostics to the project data worklog
- * so repair history is preserved across sessions.
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getProjectDataDir } from "./file-utils.js";
-import { redactSecrets } from "./redact/secrets.js";
-// --- Paths ---
-export function getWorklogPath(cwd) {
-    return path.join(getProjectDataDir(cwd), "worklog.jsonl");
-}
-// --- Write ---
-/**
- * Append diagnostics to the worklog. Pass `autoFixed: true` for
- * diagnostics that were already fixed by the tool, `false` for
- * diagnostics that are fixable but require agent action.
- */
-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 = {
-                timestamp,
-                filePath: d.filePath,
-                rule: d.rule ?? d.id ?? "unknown",
-                tool: d.tool,
-                message: d.message,
-                line: d.line ?? 1,
-                column: d.column,
-                fixable: d.fixable ?? false,
-                fixSuggestion: d.fixSuggestion,
-                autoFixed,
-                model,
-                provider,
-            };
-            return JSON.stringify(entry);
-        })
-            .join("\n") + "\n";
-        // Diagnostic messages can quote offending source lines (e.g. a
-        // secret-scanner finding), so scrub credential-shaped text before the
-        // worklog reaches disk — same boundary contract as the NDJSON loggers
-        // (#327). Replacements are JSON-string-safe, so each line stays parseable.
-        fs.appendFileSync(worklogPath, redactSecrets(lines), "utf8");
-    }
-    catch {
-        // Non-fatal — worklog write failure should never surface to the agent
-    }
-}
-// --- Read ---
-export function readWorklog(cwd) {
-    const worklogPath = getWorklogPath(cwd);
-    try {
-        const raw = fs.readFileSync(worklogPath, "utf8");
-        return raw
-            .split(/\r?\n/)
-            .filter(Boolean)
-            .flatMap((line) => {
-            try {
-                return [JSON.parse(line)];
-            }
-            catch {
-                return [];
-            }
-        });
-    }
-    catch {
-        return [];
-    }
-}
-export function summarizeWorklog(cwd) {
-    const entries = readWorklog(cwd);
-    const byRule = new Map();
-    let totalAutoFixed = 0;
-    let totalFixable = 0;
-    for (const e of entries) {
-        const r = byRule.get(e.rule) ?? { count: 0, autoFixed: 0 };
-        r.count++;
-        if (e.autoFixed) {
-            r.autoFixed++;
-            totalAutoFixed++;
-        }
-        if (e.fixable)
-            totalFixable++;
-        byRule.set(e.rule, r);
-    }
-    return {
-        totalAutoFixed,
-        totalFixable,
-        byRule: [...byRule.entries()]
-            .map(([rule, v]) => ({ rule, ...v }))
-            .sort((a, b) => b.count - a.count),
-    };
-}

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

@@ -1,343 +0,0 @@
-/**
- * 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). `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
- * 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";
-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;
-const liveEmitter = createLiveBusEmitter();
-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) {
-    liveEmitter.wire(emitFn);
-}
-export function wireFormatEventsBusEmitterGetter(getter) {
-    liveEmitter.wireGetter(getter);
-}
-/** Test-only: reset module state between test files. */
-export function _resetFormatEventsPublishForTests() {
-    liveEmitter.reset();
-    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;
-    }
-    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({
-                event: BUS_FORMAT_QUEUED_EVENT,
-                outcome: "skipped_unwired",
-                cwd: normalizeFilePath(args.cwd),
-            });
-        }
-        return;
-    }
-    const busEmit = resolution.emit;
-    try {
-        const payload = {
-            v: BUS_FORMAT_QUEUED_VERSION,
-            source: "pi-lens",
-            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",
-            cwd: payload.cwd,
-            fileCount: 1,
-        });
-    }
-    catch (err) {
-        logBusEvent({
-            event: BUS_FORMAT_QUEUED_EVENT,
-            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}`);
-        }
-    }
-}
-/**
- * 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;
-    }
-    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({
-                event: BUS_FORMAT_START_EVENT,
-                outcome: "skipped_unwired",
-                cwd: normalizeFilePath(args.cwd),
-            });
-        }
-        return;
-    }
-    const busEmit = resolution.emit;
-    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,
-            kinds: args.kinds ?? ["format"],
-        };
-        busEmit(BUS_FORMAT_START_EVENT, payload);
-        hasLoggedStartFailure = false;
-        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),
-            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}`);
-        }
-    }
-}
-/**
- * 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;
-    }
-    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({
-                event: BUS_AUTOFIX_START_EVENT,
-                outcome: "skipped_unwired",
-                cwd: normalizeFilePath(args.cwd),
-            });
-        }
-        return;
-    }
-    const busEmit = resolution.emit;
-    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);
-        hasLoggedAutofixStartFailure = false;
-        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),
-            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

@@ -1,222 +0,0 @@
-/**
- * Format Service for pi-lens
- *
- * Concurrent formatter execution using Effect-TS.
- * Auto-formats files on write with a single selected formatter per file.
- *
- * Key features:
- * - Chooses one formatter per file using config-gated or smart-default policy
- * - Runs formatting with timeout protection
- * - 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 { loadFormatters } from "./formatters-lazy.js";
-import { bounded } from "./deadline-utils.js";
-// --- Configuration ---
-/** Reserved for future batching; formatting currently runs one selected formatter per file. */
-const DEFAULT_FORMATTER_CONCURRENCY = 1;
-// --- Format Service ---
-export class FormatService {
-    fileTime;
-    enabled;
-    constructor(sessionID, enabled = true) {
-        this.fileTime = new FileTime(sessionID);
-        this.enabled = enabled;
-    }
-    /**
-     * Format a file with the single selected formatter for that file.
-     */
-    async formatFile(filePath, options = {}) {
-        const absolutePath = path.resolve(filePath);
-        const cwd = path.dirname(absolutePath);
-        // Skip if disabled
-        if (options.skip || !this.enabled) {
-            return {
-                filePath: absolutePath,
-                formatters: [],
-                anyChanged: false,
-                allSucceeded: true,
-            };
-        }
-        // Check if file was modified externally (safety check)
-        if (this.fileTime.hasChanged(absolutePath)) {
-            logExtension({
-                subsystem: "format",
-                level: "warn",
-                message: `File ${absolutePath} modified externally, skipping format`,
-                metadata: { filePath: absolutePath },
-            });
-            return {
-                filePath: absolutePath,
-                formatters: [],
-                anyChanged: false,
-                allSucceeded: false,
-            };
-        }
-        // Get formatters for this file
-        const formatters = options.formatters
-            ? await this.getFormattersByName(options.formatters)
-            : await (await loadFormatters()).getFormattersForFile(absolutePath, cwd);
-        if (formatters.length === 0) {
-            return {
-                filePath: absolutePath,
-                formatters: [],
-                anyChanged: false,
-                allSucceeded: true,
-            };
-        }
-        // Run formatters with limited concurrency
-        const results = await this.runFormattersWithConcurrency(absolutePath, formatters, DEFAULT_FORMATTER_CONCURRENCY, options.signal, options.budgetMs, options.hook);
-        // Record new file state after formatting
-        this.fileTime.read(absolutePath);
-        for (const [index, result] of results.entries()) {
-            recordFormatter(absolutePath, formatters[index]?.name ?? "unknown", result.changed, result.success, result.outcome);
-        }
-        // Build summary
-        const anyChanged = results.some((r) => r.changed);
-        const allSucceeded = results.every((r) => r.success);
-        return {
-            filePath: absolutePath,
-            formatters: results.map((r, i) => ({
-                name: formatters[i].name,
-                success: r.success,
-                changed: r.changed,
-                ...(r.error === undefined ? {} : { error: r.error }),
-                outcome: r.outcome,
-            })),
-            anyChanged,
-            allSucceeded,
-        };
-    }
-    /**
-     * Run the selected formatter with timeout protection.
-     */
-    async runFormattersWithConcurrency(filePath, formatters, _concurrency = DEFAULT_FORMATTER_CONCURRENCY, signal, budgetMs = 30_000, hook = "tool_result_edit") {
-        const results = [];
-        const startedAt = Date.now();
-        for (const formatter of formatters) {
-            const remainingMs = budgetMs - (Date.now() - startedAt);
-            if (remainingMs <= 0) {
-                results.push({
-                    success: false,
-                    changed: false,
-                    outcome: "failed",
-                    error: `Formatter aggregate budget exhausted before ${formatter.name}`,
-                });
-                continue;
-            }
-            // The shared bound owns both the aggregate timer and abort listener.
-            // This keeps one total formatter budget per file instead of re-arming a
-            // 30s timer for every formatter.
-            try {
-                const result = await bounded(loadFormatters().then(({ formatFile }) => formatFile(filePath, formatter)), {
-                    ms: remainingMs,
-                    signal,
-                    hook,
-                    label: "formatter-aggregate",
-                });
-                if (result)
-                    results.push(result);
-                else if (signal?.aborted) {
-                    // Caller cancellation is intentional. Do not turn Escape into a
-                    // formatter failure or requeue record.
-                    break;
-                }
-                else {
-                    results.push({
-                        success: false,
-                        changed: false,
-                        outcome: "failed",
-                        error: `Formatter ${formatter.name} exceeded aggregate budget`,
-                    });
-                    break;
-                }
-            }
-            catch (error) {
-                // A timeout or thrown error here is a real failure (#2413): the
-                // formatter ran and did not complete, distinct from an unavailable
-                // executable (which formatFile classifies before spawning).
-                results.push({
-                    success: false,
-                    changed: false,
-                    outcome: "failed",
-                    error: error instanceof Error ? error.message : String(error),
-                });
-            }
-        }
-        return results;
-    }
-    /**
-     * Get formatters by name (for explicit formatter selection)
-     */
-    async getFormattersByName(names) {
-        const { listAllFormatters, ...formatters } = await loadFormatters();
-        const allNames = listAllFormatters();
-        return names
-            .filter((name) => allNames.includes(name))
-            .map((name) => {
-            // Convert hyphenated name to camelCase then append Formatter
-            // e.g. "php-cs-fixer" → "phpCsFixerFormatter", "clang-format" → "clangFormatFormatter"
-            const camel = name.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
-            const key = `${camel}Formatter`;
-            return formatters[key];
-        })
-            .filter(Boolean);
-    }
-    /**
-     * Assert file hasn't changed before editing
-     * Throws FileTimeError if file modified externally
-     */
-    assertUnchanged(filePath) {
-        this.fileTime.assert(filePath);
-    }
-    /**
-     * Check if file has changed externally
-     */
-    hasChanged(filePath) {
-        return this.fileTime.hasChanged(filePath);
-    }
-    /**
-     * Record file read (after agent reads file)
-     */
-    recordRead(filePath) {
-        this.fileTime.read(filePath);
-    }
-    /**
-     * Clear detection cache
-     */
-    clearCache() {
-        void loadFormatters().then(({ clearFormatterRuntimeState }) => clearFormatterRuntimeState());
-    }
-}
-// --- Singleton Instance ---
-let globalFormatService = null;
-let currentSessionID = null;
-export function getFormatService(sessionID, enabled = true) {
-    // Create new instance if:
-    // 1. No service exists yet
-    // 2. Session ID changed (different session)
-    const shouldCreateNew = !globalFormatService || (sessionID && sessionID !== currentSessionID);
-    if (shouldCreateNew) {
-        globalFormatService = new FormatService(sessionID ?? "default", enabled);
-        currentSessionID = sessionID ?? "default";
-    }
-    return globalFormatService;
-}
-export function resetFormatService() {
-    void loadFormatters().then(({ clearFormatterRuntimeState }) => clearFormatterRuntimeState());
-    globalFormatService = null;
-    currentSessionID = null;
-}
-/**
- * Reset format service and clear all file tracking state.
- * Use this in tests to ensure complete isolation.
- */
-export function clearFormatServiceAndFileState() {
-    resetFormatService();
-}
-// Re-export for convenience

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

@@ -1,9 +0,0 @@
-/** Shared lazy formatter catalog seam (#1394). */
-import { createLazyImport } from "./lazy-import.js";
-const lazyFormatters = createLazyImport(() => import("./formatters.js"));
-export function warmFormatters() {
-    return lazyFormatters.get();
-}
-export function loadFormatters() {
-    return warmFormatters();
-}