pi-lens 4.3.0 → 4.4.0

package/dist/clients/partial-edit-apply.js

@@ -1,439 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import { writeFileAtomic } from "./atomic-write.js";
-import { createFileTime } from "./file-time.js";
-import { detectLineEnding, normalizeToLF, restoreLineEndings, } from "./host-edit-normalize.js";
-import { PathKeyedMap } from "./path-keyed-map.js";
-import { normalizeMapKey } from "./path-utils.js";
-import { boundedEditIndexes, createReadGuardEditBatchSummary, formatBoundedEditIndexes, logReadGuardEvent, } from "./read-guard-logger.js";
-const MAX_APPLIED_RECORDS_PER_FILE = 8;
-/** Exported for #2442's bounded-eviction test; not a public API. */
-export const MAX_APPLIED_RECORD_FILES = 64;
-/**
- * Canonical key for an applied edit: LF-normalized, per-line trailing
- * whitespace stripped, trailing empty lines dropped. Retry payloads go through
- * the same normalization, so an identical resubmission matches its record even
- * when the two passes' autopatch results diverged on trailing whitespace
- * (deterministic given identical payloads; the strip removes the only
- * payload-dependent axis that survives to the retry).
- */
-export function stripOldTextTrailingWhitespace(value) {
-    const lines = value
-        .replace(/\r\n/g, "\n")
-        .split("\n")
-        .map((l) => l.trimEnd());
-    while (lines.length > 1 && lines[lines.length - 1] === "")
-        lines.pop();
-    return lines.join("\n");
-}
-function editPairDigest(oldText, newText) {
-    return createHash("sha256")
-        .update(JSON.stringify([oldText, newText ?? ""]), "utf8")
-        .digest("hex");
-}
-function countLfOccurrences(content, needle) {
-    if (!needle)
-        return 0;
-    let count = 0;
-    let pos = 0;
-    while (pos < content.length) {
-        const idx = content.indexOf(needle, pos);
-        if (idx === -1)
-            break;
-        count += 1;
-        pos = idx + needle.length;
-    }
-    return count;
-}
-/**
- * Evidence check for an exact-retry recognition (#2402): the recorded pair was
- * applied by this process; the content evidence answers whether that state is
- * still the file's state. Deliberately NOT a global heuristic — it only runs
- * for an edit whose exact (oldText, newText) pair is on record.
- *
- * - oldText not contained in newText: the applied state holds when oldText is
- *   gone and newText is present.
- * - oldText contained in newText (e.g. an extended import line): the applied
- *   state holds when every remaining oldText occurrence lies inside a newText
- *   occurrence. Re-applying would duplicate newText — the exact #2402 loop.
- */
-export function isExactAppliedRetry(args) {
-    const { contentLf, oldKey, newKey, contentHash, expectedContentHash, expectedAfterWriteHash, } = args;
-    // Hash gate (fail-safe): when the caller recorded any file-state hash, the
-    // current file must match one of the states THIS process produced — the
-    // post-commit bytes or the post-afterWrite (formatter) bytes. A file in any
-    // other state is an unrecognized third-party change; we refuse rather than
-    // re-resolve against it. The gate is skipped only when no hash was recorded.
-    const haveExpectedHash = expectedContentHash !== undefined || expectedAfterWriteHash !== undefined;
-    if (haveExpectedHash) {
-        const matchesKnownState = contentHash !== undefined &&
-            (contentHash === expectedContentHash ||
-                contentHash === expectedAfterWriteHash);
-        if (!matchesKnownState)
-            return false;
-    }
-    if (!oldKey)
-        return false;
-    if (newKey === "")
-        return countLfOccurrences(contentLf, oldKey) === 0;
-    if (!newKey.includes(oldKey)) {
-        return (countLfOccurrences(contentLf, oldKey) === 0 &&
-            countLfOccurrences(contentLf, newKey) >= 1);
-    }
-    const newOccurrences = [];
-    let pos = 0;
-    while (pos < contentLf.length) {
-        const idx = contentLf.indexOf(newKey, pos);
-        if (idx === -1)
-            break;
-        newOccurrences.push([idx, idx + newKey.length]);
-        pos = idx + newKey.length;
-    }
-    if (newOccurrences.length === 0)
-        return false;
-    pos = 0;
-    while (pos < contentLf.length) {
-        const idx = contentLf.indexOf(oldKey, pos);
-        if (idx === -1)
-            break;
-        const end = idx + oldKey.length;
-        if (!newOccurrences.some(([s, e]) => s <= idx && e >= end))
-            return false;
-        pos = end;
-    }
-    return true;
-}
-/**
- * Session-scoped store of applied partial/full edits, keyed by normalized file
- * path. `RuntimeCoordinator.resetForSession` clears it, so an applied record
- * never outlives the session whose edit produced it. Records are bounded on
- * both axes (per-file entries, and files) with oldest-entry eviction.
- */
-export class PartialApplyRecordStore {
-    // Bounded on the PathKeyedMap itself (#2442): the file axis used to
-    // hand-roll `keys().next().value` here, which also evicted an unrelated
-    // file when a path ALREADY in the map was re-recorded at capacity.
-    files = new PathKeyedMap(normalizeMapKey, MAX_APPLIED_RECORD_FILES);
-    find(filePath, oldText, newText) {
-        if (!oldText)
-            return undefined;
-        const pairDigest = editPairDigest(oldText, newText);
-        const records = this.files.get(filePath) ?? [];
-        return records.find((r) => r.pairDigest === pairDigest);
-    }
-    record(filePath, oldText, newText, contentHash) {
-        if (!oldText)
-            return;
-        const pairDigest = editPairDigest(oldText, newText);
-        const records = this.files.get(filePath) ?? [];
-        const existing = records.findIndex((r) => r.pairDigest === pairDigest);
-        if (existing >= 0)
-            records.splice(existing, 1);
-        const entry = {
-            pairDigest,
-            contentHash: contentHash ?? hashFile(filePath),
-            appliedAtMs: Date.now(),
-        };
-        if (records.length >= MAX_APPLIED_RECORDS_PER_FILE)
-            records.shift();
-        records.push(entry);
-        this.files.set(filePath, records); // the map bounds its own file axis
-    }
-    /**
-     * Stamps the post-afterWrite file hash onto an existing record so a later
-     * identical retry against the formatter-rewritten file is still recognized as
-     * already-applied (#2402). No-op when the pair was never recorded.
-     */
-    noteAfterWriteHash(filePath, oldText, newText, afterWriteContentHash) {
-        if (!oldText)
-            return;
-        const pairDigest = editPairDigest(oldText, newText);
-        const record = this.files
-            .get(filePath)
-            ?.find((r) => r.pairDigest === pairDigest);
-        if (record)
-            record.afterWriteContentHash = afterWriteContentHash;
-    }
-    clear() {
-        this.files.clear();
-    }
-    get fileCount() {
-        return this.files.size;
-    }
-}
-// Locks are process-global in FileTime (module-global map keyed by resolved
-// path), so one instance here serializes against every other FileTime user.
-const fileLock = createFileTime("partial-edit-apply");
-function hashBytes(content) {
-    return createHash("sha256").update(content).digest("hex");
-}
-function hashFile(filePath) {
-    try {
-        return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Internal rejection signal: raised only BEFORE any bytes are written, so a
- * rejection can never be confused with a commit failure.
- */
-class PartialApplyRejectionError extends Error {
-    reason;
-    detail;
-    constructor(reason, detail) {
-        super(detail);
-        this.reason = reason;
-        this.detail = detail;
-        this.name = "PartialApplyRejectionError";
-    }
-}
-/**
- * Applies preflight-approved spans from the original snapshot, then invokes the
- * caller's normal post-edit bookkeeping/pipeline hook (#1053, #2402).
- *
- * Contract:
- * - Spans are consumed as resolved; oldText is never re-searched against a
- *   changed buffer.
- * - The whole batch is validated (snapshot identity, span bounds, span text,
- *   pairwise non-overlap) BEFORE any write; a rejection writes nothing and
- *   dispatches no post-edit pipeline.
- * - The commit goes through the shared atomic writer under the file lock.
- * - A committed write and a post-edit analysis failure are separate outcomes;
- *   the caller decides the message, and committed bytes are never reported as
- *   a retryable oldText miss.
- */
-export async function applyPartiallyApplicableEdits(args) {
-    const startedAt = Date.now();
-    const summaryRef = args.summary;
-    const correlationId = args.correlationId;
-    const logBatchEvent = (entry) => logReadGuardEvent({ ...entry, correlationId });
-    const reject = (reason, detail) => {
-        logBatchEvent({
-            event: "edit_partial_apply_rejected",
-            filePath: args.filePath,
-            metadata: {
-                tool: "edit",
-                rejectionReason: reason,
-                detail,
-                editCount: args.edits.length,
-            },
-        });
-        return {
-            appliedCount: 0,
-            appliedTotal: 0,
-            appliedIndices: "",
-            postEditStatus: "not_run",
-            rejected: { reason, detail },
-        };
-    };
-    if (args.edits.length === 0) {
-        return reject("invalid_batch", "no preflight-approved edits were carried into the apply step");
-    }
-    const snapshot = args.edits[0].snapshot;
-    for (const edit of args.edits) {
-        if (edit.snapshot.hash !== snapshot.hash) {
-            return reject("invalid_batch", "carried edits reference different snapshot identities; the batch must be rebuilt from one preflight");
-        }
-    }
-    // Validate + commit inside the file lock so a concurrent same-file writer
-    // (formatter, LSP edit, another session's partial apply) cannot interleave
-    // between the identity re-check and the rename.
-    const commit = () => {
-        const rawBytes = fs.readFileSync(args.filePath);
-        if (hashBytes(rawBytes) !== snapshot.hash) {
-            throw new PartialApplyRejectionError("stale_snapshot", "the file changed since the preflight resolved these edits; rebuild the edit from the current content");
-        }
-        const raw = rawBytes.toString("utf8");
-        const ending = detectLineEnding(raw);
-        const lf = normalizeToLF(raw);
-        // The span-text equality is the single span guard: `slice` clamps to the
-        // buffer, so an out-of-bounds, inverted, or drifted span cannot produce
-        // the approved text and is rejected here as one rejection class. A
-        // separate bounds check would only re-label the same failure.
-        const ordered = [...args.edits].sort((a, b) => a.spanStart - b.spanStart);
-        for (let i = 0; i < ordered.length; i += 1) {
-            const edit = ordered[i];
-            if (lf.slice(edit.spanStart, edit.spanEnd) !== edit.appliedSpanText) {
-                throw new PartialApplyRejectionError("span_changed", `edits[${edit.originalIndex}] span no longer holds the text the preflight approved; the batch must be rebuilt from a fresh preflight`);
-            }
-            if (i > 0) {
-                const prev = ordered[i - 1];
-                if (edit.spanStart < prev.spanEnd) {
-                    throw new PartialApplyRejectionError("span_overlap", `edits[${prev.originalIndex}] and edits[${edit.originalIndex}] resolved to overlapping spans; extend one oldText to disambiguate the location`);
-                }
-            }
-        }
-        let committed = lf;
-        for (let i = ordered.length - 1; i >= 0; i -= 1) {
-            const edit = ordered[i];
-            const newText = normalizeToLF(edit.newText ?? "");
-            committed =
-                committed.slice(0, edit.spanStart) +
-                    newText +
-                    committed.slice(edit.spanEnd);
-        }
-        const output = restoreLineEndings(committed, ending);
-        const targetPath = fs.lstatSync(args.filePath).isSymbolicLink()
-            ? fs.realpathSync(args.filePath)
-            : args.filePath;
-        const mode = fs.statSync(args.filePath).mode & 0o7777;
-        writeFileAtomic(targetPath, output, {
-            bestEffort: false,
-            mode,
-        });
-        return hashBytes(Buffer.from(output, "utf8"));
-    };
-    let commitStatus = "committed";
-    let committedContentHash;
-    try {
-        await fileLock.withLock(args.filePath, async () => {
-            committedContentHash = commit();
-            for (const edit of args.edits) {
-                args.recordStore?.record(args.filePath, edit.oldText, edit.newText, committedContentHash);
-            }
-        });
-    }
-    catch (error) {
-        if (error instanceof PartialApplyRejectionError) {
-            commitStatus = "not_attempted";
-            const baseSummary = summaryRef ??
-                createReadGuardEditBatchSummary({
-                    requestedIndexes: boundedEditIndexes(args.edits.map((edit) => edit.originalIndex)),
-                    requestedTotal: args.edits.length,
-                });
-            const summary = createReadGuardEditBatchSummary({
-                ...baseSummary,
-                participantIds: correlationId
-                    ? [...baseSummary.participantIds, correlationId]
-                    : baseSummary.participantIds,
-                participantTotal: correlationId
-                    ? baseSummary.participantTotal + 1
-                    : baseSummary.participantTotal,
-                commitStatus,
-                postEditStatus: "not_run",
-                terminalStatus: "blocked",
-                durationMs: Date.now() - startedAt,
-            });
-            logBatchEvent({
-                event: "edit_batch_summary",
-                filePath: args.filePath,
-                metadata: { tool: "edit", editBatchSummary: summary },
-            });
-            return reject(error.reason, error.detail);
-        }
-        commitStatus = "failed";
-        if (summaryRef || correlationId) {
-            const summary = createReadGuardEditBatchSummary({
-                ...(summaryRef ?? {
-                    requestedIndexes: boundedEditIndexes(args.edits.map((edit) => edit.originalIndex)),
-                    requestedTotal: args.edits.length,
-                }),
-                appliedIndexes: [],
-                appliedTotal: 0,
-                participantIds: correlationId ? [correlationId] : undefined,
-                participantTotal: correlationId ? 1 : undefined,
-                commitStatus,
-                terminalStatus: "failed",
-                durationMs: Date.now() - startedAt,
-            });
-            logBatchEvent({
-                event: "edit_batch_summary",
-                filePath: args.filePath,
-                metadata: { tool: "edit", editBatchSummary: summary },
-            });
-        }
-        throw error;
-    }
-    let postEditOutput;
-    let postEditStatus = "not_run";
-    if (args.afterWrite) {
-        try {
-            postEditOutput = await args.afterWrite();
-            postEditStatus = "succeeded";
-            // #2402: the afterWrite pipeline (a formatter) may have rewritten the
-            // file. Record the new state so an identical retry against the
-            // formatted bytes is still recognized as already-applied instead of
-            // falling back to oldText resolution and re-applying. Only stamped when
-            // the pipeline actually changed the bytes; the post-commit hash already
-            // covers a no-op pass.
-            if (args.recordStore) {
-                const afterWriteHash = hashFile(args.filePath);
-                if (afterWriteHash !== undefined &&
-                    afterWriteHash !== committedContentHash) {
-                    for (const edit of args.edits) {
-                        args.recordStore.noteAfterWriteHash(args.filePath, edit.oldText, edit.newText, afterWriteHash);
-                    }
-                }
-            }
-        }
-        catch (error) {
-            // The write is committed. Preserve the existing caller behavior for
-            // uninstrumented callers; the read-guard path records and handles it.
-            postEditStatus = "failed";
-            if (!summaryRef && !correlationId)
-                throw error;
-        }
-    }
-    const appliedIndexes = boundedEditIndexes(args.edits.map((edit) => edit.originalIndex));
-    if (!summaryRef && !correlationId) {
-        return {
-            appliedCount: args.edits.length,
-            appliedTotal: args.edits.length,
-            appliedIndices: formatBoundedEditIndexes(appliedIndexes),
-            postEditOutput,
-            postEditStatus,
-        };
-    }
-    const baseSummary = summaryRef ??
-        createReadGuardEditBatchSummary({
-            requestedIndexes: appliedIndexes,
-            requestedTotal: args.edits.length,
-            resolvedIndexes: appliedIndexes,
-            resolvedTotal: args.edits.length,
-        });
-    const summary = createReadGuardEditBatchSummary({
-        ...baseSummary,
-        appliedIndexes,
-        appliedTotal: args.edits.length,
-        participantIds: correlationId
-            ? [...baseSummary.participantIds, correlationId]
-            : baseSummary.participantIds,
-        participantTotal: correlationId
-            ? baseSummary.participantTotal + 1
-            : baseSummary.participantTotal,
-        commitStatus,
-        postEditStatus,
-        // Commit failures rethrow above, so reaching here means the commit
-        // landed; only the post-edit analysis can fail from this point on.
-        terminalStatus: postEditStatus === "failed" ? "failed" : "success",
-        durationMs: Date.now() - startedAt,
-    });
-    if (postEditStatus === "failed") {
-        logBatchEvent({
-            event: "edit_post_edit_pipeline_failed",
-            filePath: args.filePath,
-            metadata: {
-                tool: "edit",
-                commitStatus,
-                appliedCount: args.edits.length,
-                appliedIndexes,
-                appliedTotal: args.edits.length,
-            },
-        });
-    }
-    logBatchEvent({
-        event: "edit_batch_summary",
-        filePath: args.filePath,
-        metadata: { tool: "edit", editBatchSummary: summary },
-    });
-    return {
-        appliedCount: args.edits.length,
-        appliedTotal: args.edits.length,
-        appliedIndices: formatBoundedEditIndexes(appliedIndexes),
-        postEditOutput,
-        postEditStatus,
-        summary,
-    };
-}

package/dist/clients/path-attribution-telemetry.js

@@ -1,43 +0,0 @@
-import { logLatency } from "./latency-logger.js";
-import { getProcessSingleton } from "./process-singletons.js";
-// Verified guesses are expected host behavior, not degradations. Keep their
-// exact session count in memory and publish one bounded row at session end.
-// This tally is intentionally memory-only: a process crash loses its count.
-// The rollup is best-effort session telemetry, not durable accounting.
-//
-// Process-singleton backed (AGENTS.md catalog shape 25), NOT a module-scope
-// `let` like `bus-events-logger.ts`'s rollup: a `let` here exists once per
-// module EVALUATION, not once per process, and #2146 measured one pid
-// evaluating this graph nine times — a bare `let` would only ever count the
-// guesses routed through its own copy, undercounting every rollup that is not
-// reached through the first evaluation. This is the same decision its sibling
-// `session-start-observability.ts`'s bind rollup made in #2249.
-const VERIFIED_GUESS_FAMILY = "path-attribution-verified-guess-count";
-const VERIFIED_GUESS_VERSION = 1;
-function verifiedGuessCount() {
-    return getProcessSingleton(VERIFIED_GUESS_FAMILY, VERIFIED_GUESS_VERSION, () => ({
-        count: 0,
-    }));
-}
-export function recordVerifiedPathAttributionGuess() {
-    verifiedGuessCount().count += 1;
-}
-export function getVerifiedPathAttributionGuessCount() {
-    return verifiedGuessCount().count;
-}
-export function emitVerifiedPathAttributionRollup(filePath) {
-    const cell = verifiedGuessCount();
-    if (cell.count === 0)
-        return;
-    logLatency({
-        type: "phase",
-        phase: "path_attribution_verified_rollup",
-        filePath,
-        durationMs: 0,
-        metadata: { count: cell.count },
-    });
-    cell.count = 0;
-}
-export function resetVerifiedPathAttributionGuessCount() {
-    verifiedGuessCount().count = 0;
-}

package/dist/clients/path-keyed-map.js

@@ -1,108 +0,0 @@
-/**
- * A `Map` for file-path keys that folds every key through a caller-supplied
- * normalizer INTERNALLY, so keying on a raw (non-normalized) path is
- * structurally impossible — the whole path-key divergence class (#1025,
- * follow-up to #1020/#210) collapses to "pick the right normalizer once, at
- * construction," instead of every call site having to remember to normalize on
- * write AND read AND delete (the exact discipline #210 declared and #1020
- * proved is easy to miss).
- *
- * The normalizer runs on EVERY `get`/`set`/`has`/`delete`, so two
- * differently-formed keys for the same path (`SUB\a.ts` vs `sub/a.ts`, on a
- * case-insensitive FS) collapse to a single entry — no silent duplicate, no
- * `has()` miss, no orphaned stale entry.
- *
- * Values retain their ORIGINAL display path. Consumers that render paths
- * (symbol_search results, footer widgets) must not see a lowercased /
- * slash-folded key, so the entry stores the display path alongside the value
- * and every iteration surface (`keys`/`values`/`entries`/`forEach`/the default
- * iterator) yields that display path — the exact form last written, never the
- * folded internal key. `set` refreshes the display path to the most recent
- * write (last-writer-wins), matching a plain `Map`'s "the key you set is the
- * key you see" intuition while still de-duplicating by normalized identity.
- *
- * Optionally BOUNDED: pass `maxEntries` and the backing store becomes a
- * `BoundedFifoMap` (see the constructor). Unbounded by default.
- *
- * Choose the normalizer to match how the keyed state is used:
- *  - `normalizeEphemeralMapKey` (path-utils.ts) — cheap slash-fold +
- *    win32-lowercase, NO filesystem I/O — for hot, single-process, in-memory
- *    indexes whose keys this process produced itself (e.g. the word index).
- *  - `normalizeMapKey` — realpath-canonicalizing — for long-lived state shared
- *    across call sites where symlink/real-casing resolution matters.
- */
-import { BoundedFifoMap } from "./bounded-cache.js";
-export class PathKeyedMap {
-    normalize;
-    store;
-    /**
-     * `maxEntries` bounds the map with insertion-order (FIFO) eviction, on
-     * `BoundedFifoMap` — the repo's one eviction implementation (#2442). Omit
-     * it for an unbounded map. A path-keyed map that needs a bound gets it
-     * here rather than hand-rolling `keys().next().value` at the call site,
-     * which is what `PartialApplyRecordStore` did before #2442's review round.
-     *
-     * FIFO, not LRU, and evicting AFTER the write, not before: a `set` of an
-     * already-resident path is an update, and must not drop an unrelated file
-     * to make room for a key that needs none.
-     */
-    constructor(normalize, maxEntries) {
-        this.normalize = normalize;
-        this.store =
-            maxEntries === undefined
-                ? new Map()
-                : new BoundedFifoMap(maxEntries);
-    }
-    get size() {
-        return this.store.size;
-    }
-    get(path) {
-        return this.store.get(this.normalize(path))?.value;
-    }
-    has(path) {
-        return this.store.has(this.normalize(path));
-    }
-    set(path, value) {
-        this.store.set(this.normalize(path), { displayPath: path, value });
-        return this;
-    }
-    delete(path) {
-        if (this.store.delete(this.normalize(path)))
-            return true;
-        // A filesystem-aware normalizer can change after the keyed file is
-        // deleted (for example, real on-disk casing becomes a lowercased missing
-        // tail on Windows). The caller may still hold the exact display key it
-        // received from this map. Honor that captured identity without deriving a
-        // second path form, so deletion remains possible across existence changes.
-        for (const [key, entry] of this.store) {
-            if (entry.displayPath !== path)
-                continue;
-            this.store.delete(key);
-            return true;
-        }
-        return false;
-    }
-    clear() {
-        this.store.clear();
-    }
-    *keys() {
-        for (const entry of this.store.values())
-            yield entry.displayPath;
-    }
-    *values() {
-        for (const entry of this.store.values())
-            yield entry.value;
-    }
-    *entries() {
-        for (const entry of this.store.values())
-            yield [entry.displayPath, entry.value];
-    }
-    forEach(callback) {
-        for (const entry of this.store.values()) {
-            callback(entry.value, entry.displayPath, this);
-        }
-    }
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-}