@pugi/cli 0.1.0-beta.8 → 0.1.0-beta.87

package/dist/core/edits/fuzzy-ladder.js

@@ -0,0 +1,650 @@
+/**
+ * Layer A.5 — Aider-inspired fuzzy SEARCH/REPLACE ladder.
+ *
+ * Sits between Layer A strict-exact match and Layer B/C escalation. Off
+ * by default; opt-in via `--fuzzy-edits` CLI flag or `fuzzy: true` on
+ * the dispatcher options. The ladder fires ONLY after Layer A returned
+ * `no_match`; ambiguous / file_missing / write_error short-circuit
+ * straight through because a fuzzy retry on an ambiguous block would
+ * make a bad situation worse (silently picking one of N matches).
+ *
+ * Three tiers, tried in order. First success wins.
+ *
+ *  1. whitespace-flex — detect a UNIFORM leading-whitespace delta
+ *     across every line of the SEARCH block and re-strip the source
+ *     slice by the same amount. Matches the common LLM failure mode
+ *     where the model dropped (or added) a consistent indent prefix
+ *     relative to what the file actually contains.
+ *
+ *  2. ellipsis allowance — when the SEARCH block contains a bare
+ *     `...` line, split на head + tail (or head + middle + tail),
+ *     anchor head's start and tail's end in the source, preserve
+ *     whatever sits in the middle, and rebuild the replacement by
+ *     analogy. The model uses this when the block-to-replace spans
+ *     a large stretch and only the boundaries are unique.
+ *
+ *  3. edit-distance match — slide a window of length comparable to
+ *     the SEARCH block over the source. For each candidate run a
+ *     longest-common-subsequence ratio (`SequenceMatcher.ratio()`
+ *     equivalent — `2*M / (|A|+|B|)`). Best candidate must score
+ *     >= 0.8 to count as a match; below that we fail LOUD rather
+ *     than write the wrong region.
+ *
+ * Inspired by Aider editblock_coder.py (Apache-2.0). Clean-room
+ * implementation; no Aider source code copied.
+ *
+ * Pure functions throughout — every tier returns a structured result
+ * and never touches the filesystem. The dispatcher integration in
+ * `layer-a-apply-fuzzy.ts` (the actual disk-write wrapper) is the only
+ * code path that mutates state.
+ */
+const DEFAULT_MIN_RATIO = 0.8;
+const DEFAULT_LENGTH_FLEX = 0.1;
+/**
+ * Run the full ladder against `source` for the SEARCH/REPLACE pair.
+ *
+ * Returns the first tier that produces a unique match. If every tier
+ * fails, returns `no_match` with a composite detail. The dispatcher
+ * surfaces this as `fuzzy_no_match` so the model sees that even the
+ * relaxed matching could not anchor the block.
+ */
+export function tryFuzzyLadder(source, search, replace, opts = {}) {
+    // Empty search would match anywhere; we refuse the same way Layer A
+    // rejects empty oldString. Defensive; the dispatcher already gates
+    // on this upstream.
+    if (search.length === 0) {
+        return { kind: 'no_match', detail: 'empty search block' };
+    }
+    // Tier 1 — whitespace-flex.
+    const wsResult = tryWhitespaceFlex(source, search, replace);
+    if (wsResult.kind === 'matched' || wsResult.kind === 'ambiguous')
+        return wsResult;
+    // Tier 2 — ellipsis. Only meaningful when the search actually
+    // contains `...`; the helper short-circuits otherwise so the
+    // composite diagnostic stays clean.
+    const ellipsisResult = tryEllipsis(source, search, replace);
+    if (ellipsisResult.kind === 'matched' || ellipsisResult.kind === 'ambiguous')
+        return ellipsisResult;
+    // Tier 3 — edit distance. Final tier; failure here ends the ladder.
+    const distResult = tryEditDistance(source, search, replace, opts);
+    if (distResult.kind === 'matched' || distResult.kind === 'ambiguous')
+        return distResult;
+    return {
+        kind: 'no_match',
+        detail: `fuzzy ladder exhausted: ws=${wsResult.detail}; ellipsis=${ellipsisResult.detail}; edit-distance=${distResult.detail}`,
+    };
+}
+/**
+ * Tier 1 — whitespace-flex.
+ *
+ * The model's SEARCH block frequently differs from the source by a
+ * uniform leading-whitespace delta (e.g. the model emitted code at
+ * column 0 but the source is inside a 2-space-indented function body).
+ * We detect such a uniform delta and try the strict-equal match
+ * against the re-indented buffer.
+ *
+ * Algorithm:
+ *  1. Strip trailing newline / split source + search into lines.
+ *  2. Skip if any non-whitespace line of search is empty (the
+ *     "uniform" claim is undefined).
+ *  3. Reject mixed indents (e.g. tab + space in the same block) so we
+ *     don't silently translate semantics.
+ *  4. For each non-empty source line, compute the source-line
+ *     leading-WS prefix. Find any window of consecutive source lines
+ *     whose stripped-content matches the stripped search lines
+ *     exactly, AND whose leading-WS prefix is uniform across the
+ *     matched window.
+ *  5. Require EXACTLY ONE such window; multiple → ambiguous.
+ *
+ * If matched, rebuild the replacement by prepending the same uniform
+ * prefix to each replace line that already starts at column 0 (relative
+ * to the search), so the indent is preserved.
+ */
+export function tryWhitespaceFlex(source, search, replace) {
+    const searchLines = splitLinesKeepEnds(search);
+    const sourceLines = splitLinesKeepEnds(source);
+    if (searchLines.length === 0) {
+        return { kind: 'no_match', detail: 'whitespace-flex: empty search' };
+    }
+    // Mixed-indent guard — if the search block mixes leading tabs and
+    // leading spaces we refuse. Aider had the same defence; mixing the
+    // two breaks the "strip N chars off every line" invariant.
+    const stripped = [];
+    const searchPrefixes = [];
+    let hadTab = false;
+    let hadSpace = false;
+    for (const line of searchLines) {
+        const { prefix, rest } = splitLeadingWs(line);
+        if (prefix.includes('\t'))
+            hadTab = true;
+        if (prefix.includes(' '))
+            hadSpace = true;
+        searchPrefixes.push(prefix);
+        stripped.push(rest);
+    }
+    if (hadTab && hadSpace) {
+        return { kind: 'no_match', detail: 'whitespace-flex: mixed tab/space indent in search' };
+    }
+    // Slide a window across source lines.
+    const matches = [];
+    const lineOffsets = computeLineOffsets(source);
+    for (let i = 0; i + searchLines.length <= sourceLines.length; i += 1) {
+        let ok = true;
+        let sharedPrefix = null;
+        for (let j = 0; j < searchLines.length; j += 1) {
+            const sourceLine = sourceLines[i + j] ?? '';
+            const { prefix: srcPrefix, rest: srcRest } = splitLeadingWs(sourceLine);
+            const searchRest = stripped[j] ?? '';
+            const searchPrefix = searchPrefixes[j] ?? '';
+            // Compare stripped (line content + line terminator). We tolerate
+            // a missing trailing newline on the LAST search line — Anthropic
+            // + OpenAI marker parsers strip the trailing newline on the last
+            // body line, so a faithful round-trip search block ends without
+            // `\n`. Matching against a source line that DOES end in `\n` is
+            // the common case for in-file edits.
+            const isLastSearchLine = j === searchLines.length - 1;
+            const restEqual = srcRest === searchRest ||
+                (isLastSearchLine && srcRest === `${searchRest}\n`);
+            if (!restEqual) {
+                ok = false;
+                break;
+            }
+            // Per-line delta = source prefix minus the search prefix. Must
+            // be uniform across the entire block — either every line shares
+            // the same source prefix, or the search block already carries a
+            // matching shape (e.g. the search and source both have nested
+            // indent inside the block, but differ in the OUTER prefix).
+            const delta = computePrefixDelta(srcPrefix, searchPrefix);
+            if (delta === null) {
+                ok = false;
+                break;
+            }
+            if (sharedPrefix === null)
+                sharedPrefix = delta;
+            else if (sharedPrefix !== delta) {
+                ok = false;
+                break;
+            }
+        }
+        if (ok && sharedPrefix !== null) {
+            const startOffset = lineOffsets[i] ?? 0;
+            const endLineEnd = lineOffsets[i + searchLines.length] ?? source.length;
+            matches.push({ start: i, end: i + searchLines.length, sourcePrefix: sharedPrefix, startOffset, endOffset: endLineEnd });
+        }
+    }
+    if (matches.length === 0) {
+        return { kind: 'no_match', detail: 'whitespace-flex: no uniform-indent candidate' };
+    }
+    if (matches.length > 1) {
+        return {
+            kind: 'ambiguous',
+            tier: 'whitespace-flex',
+            candidateCount: matches.length,
+            detail: `whitespace-flex: ${matches.length} candidates`,
+        };
+    }
+    const m = matches[0];
+    if (!m) {
+        return { kind: 'no_match', detail: 'whitespace-flex: internal — match array empty after length check' };
+    }
+    // Rebuild replacement: prepend the shared delta prefix to each
+    // replace line (keeping its own existing indent). Empty replacement
+    // lines stay empty (don't pad a blank with whitespace just for
+    // symmetry — would dirty the file).
+    const replaceLines = splitLinesKeepEnds(replace);
+    let rebuilt = replaceLines
+        .map((line) => {
+        const { rest } = splitLeadingWs(line);
+        if (rest.length === 0)
+            return line; // blank line untouched
+        // Preserve the line's own indent shape; prepend the delta. This
+        // matches Aider's behaviour: if the model emitted the replace at
+        // the same column as the search, the source's outer indent is
+        // re-applied.
+        const { prefix: replacePrefix } = splitLeadingWs(line);
+        return `${m.sourcePrefix}${replacePrefix}${rest}`;
+    })
+        .join('');
+    // If the source's matched span ended on a terminated line but the
+    // replace's last line is un-terminated, re-add the terminator. This
+    // matches the Anthropic / OpenAI parsers' habit of stripping the
+    // trailing newline on the last body line — we want к keep the
+    // source's line shape after rebuild.
+    const lastSourceLine = sourceLines[m.end - 1] ?? '';
+    if (lastSourceLine.endsWith('\n') && !rebuilt.endsWith('\n')) {
+        rebuilt += '\n';
+    }
+    const after = source.slice(0, m.startOffset) + rebuilt + source.slice(m.endOffset);
+    return {
+        kind: 'matched',
+        tier: 'whitespace-flex',
+        after,
+        score: 1,
+        startOffset: m.startOffset,
+        endOffset: m.endOffset,
+    };
+}
+/**
+ * Tier 2 — ellipsis allowance.
+ *
+ * Accept `...` on its own line (optionally with surrounding whitespace)
+ * as a wildcard span. Split the search into chunks; the first chunk's
+ * start must anchor in the source, the last chunk's end must anchor
+ * after the first chunk's match, and anything in between is preserved
+ * verbatim. With multiple `...` markers the same rule applies pairwise.
+ *
+ * Required invariants:
+ *  - At least one `...` line exists (else degrade to no_match; this
+ *    tier is a no-op for non-ellipsis blocks).
+ *  - The head chunk + tail chunk are both non-empty (otherwise there
+ *    is no anchor — the model owes us at least one line of context).
+ *  - The head chunk's exact match is UNIQUE in the source (else we
+ *    can't deterministically pick the window).
+ *
+ * On match the replacement is rebuilt by stitching the model's
+ * REPLACE chunks (parsed by the same ellipsis split) with the source's
+ * own middle preserved verbatim. The model is expected to also use
+ * `...` markers in the REPLACE block to indicate "keep the middle";
+ * if the REPLACE has no markers we treat it as a verbatim replacement
+ * for the entire matched span (head + middle + tail).
+ */
+export function tryEllipsis(source, search, replace) {
+    const searchParts = splitOnEllipsis(search);
+    if (searchParts.length < 2) {
+        return { kind: 'no_match', detail: 'ellipsis: no ... marker in search' };
+    }
+    const head = searchParts[0] ?? '';
+    const tail = searchParts[searchParts.length - 1] ?? '';
+    if (head.length === 0 || tail.length === 0) {
+        return { kind: 'no_match', detail: 'ellipsis: empty head or tail chunk' };
+    }
+    // Head must be uniquely findable. Use overlap-aware enumeration —
+    // plain `indexOf` then `indexOf(_, lastIdx + head.length)` would miss
+    // a second hit that overlaps the first by `head.length - 1` chars
+    // (e.g. head "aaa" in source "aaaa" has matches at both 0 and 1,
+    // but indexOf-stride scanning only sees the one at 0). Triple-review
+    // P1-2: a multi-occurrence head must surface as `ambiguous` so
+    // the dispatcher escalates rather than silently landing the wrong
+    // span.
+    const headMatches = enumerateMatches(source, head, /* maxNeeded */ 2);
+    if (headMatches.length === 0) {
+        return { kind: 'no_match', detail: 'ellipsis: head chunk not found' };
+    }
+    if (headMatches.length > 1) {
+        return {
+            kind: 'ambiguous',
+            tier: 'ellipsis',
+            candidateCount: headMatches.length,
+            detail: 'ellipsis: head chunk matches multiple times',
+        };
+    }
+    const headFirst = headMatches[0] ?? 0;
+    const innerAnchors = [];
+    let cursor = headFirst + head.length;
+    for (let i = 1; i < searchParts.length - 1; i += 1) {
+        const chunk = searchParts[i] ?? '';
+        if (chunk.length === 0) {
+            // Empty inner chunk would match anywhere — treat as "skip"
+            // (the preserved middle on each side is contiguous).
+            continue;
+        }
+        const found = source.indexOf(chunk, cursor);
+        if (found === -1) {
+            return { kind: 'no_match', detail: `ellipsis: inner chunk #${i} not found after cursor` };
+        }
+        innerAnchors.push({ start: found, end: found + chunk.length });
+        cursor = found + chunk.length;
+    }
+    // Find the tail occurrence strictly after the last inner anchor (or
+    // after head when no inner chunks). Anchor forwards AND require
+    // uniqueness in the trailing region. Without the uniqueness gate, an
+    // SLR/SLP block whose tail repeats further down the source would land
+    // the replacement in a syntactically-plausible-but-wrong spot.
+    // Triple-review P1-1: enumerate then require exactly one match;
+    // fall through to Tier 3 (edit-distance) when ambiguous so the model
+    // sees the disambiguation request, not a silent miswrite.
+    const tailMatches = enumerateMatches(source.slice(cursor), tail, /* maxNeeded */ 2);
+    if (tailMatches.length === 0) {
+        return { kind: 'no_match', detail: 'ellipsis: tail chunk not found after head' };
+    }
+    if (tailMatches.length > 1) {
+        return {
+            kind: 'ambiguous',
+            tier: 'ellipsis',
+            candidateCount: tailMatches.length,
+            detail: 'ellipsis: tail chunk matches multiple times after head',
+        };
+    }
+    const tailStart = (tailMatches[0] ?? 0) + cursor;
+    const matchStart = headFirst;
+    const matchEnd = tailStart + tail.length;
+    // Compute the preserved-middle segments — one between every pair
+    // of consecutive REPLACE chunks (head, inner_1, ..., inner_k, tail).
+    // For k inner anchors we end up with k+1 preserved segments:
+    //  preserved[0] = source[headEnd .. innerAnchors[0].start]
+    //  preserved[i] = source[innerAnchors[i-1].end .. innerAnchors[i].start]
+    //  preserved[k] = source[innerAnchors[k-1].end .. tailStart]
+    const preserved = [];
+    let segStart = headFirst + head.length;
+    for (const a of innerAnchors) {
+        preserved.push(source.slice(segStart, a.start));
+        segStart = a.end;
+    }
+    preserved.push(source.slice(segStart, tailStart));
+    // Rebuild the replacement.
+    //
+    // Case A — REPLACE uses `...` AND has at least as many chunks as
+    //         SEARCH: interleave preserved segments между REPLACE
+    //         chunks at corresponding positions. This is the common
+    //         case: model emits the same shape on both sides.
+    //
+    // Case B — REPLACE has fewer `...` chunks than SEARCH OR no `...`
+    //         at all: treat REPLACE as the verbatim full replacement
+    //         for the matched span. Lets the model collapse a span
+    //         when the rewrite is small.
+    const replaceParts = splitOnEllipsis(replace);
+    let rebuilt;
+    if (replaceParts.length === searchParts.length && replaceParts.length >= 2) {
+        // Interleave: replaceParts[0] + preserved[0] + replaceParts[1] +
+        // preserved[1] + ... + replaceParts[last]
+        const pieces = [];
+        for (let i = 0; i < replaceParts.length; i += 1) {
+            pieces.push(replaceParts[i] ?? '');
+            if (i < preserved.length) {
+                pieces.push(preserved[i] ?? '');
+            }
+        }
+        rebuilt = pieces.join('');
+    }
+    else if (replaceParts.length >= 2) {
+        // Mismatched chunk count — splice preserved spans into the gaps
+        // we DO have, pad with the last preserved on overflow. Defensive
+        // path; production callers should match shape.
+        const rHead = replaceParts[0] ?? '';
+        const rTail = replaceParts[replaceParts.length - 1] ?? '';
+        const middleSpan = preserved.join('');
+        rebuilt = `${rHead}${middleSpan}${rTail}`;
+    }
+    else {
+        rebuilt = replace;
+    }
+    const after = source.slice(0, matchStart) + rebuilt + source.slice(matchEnd);
+    return {
+        kind: 'matched',
+        tier: 'ellipsis',
+        after,
+        score: 1,
+        startOffset: matchStart,
+        endOffset: matchEnd,
+    };
+}
+/**
+ * Tier 3 — edit-distance match via LCS ratio.
+ *
+ * Slide a window of length comparable к |search| across the source.
+ * For each candidate slice, compute the LCS-ratio
+ * `(2 * lcs(a, b)) / (|a| + |b|)`. Best-ratio candidate must score
+ * >= minRatio (default 0.8) to count as a match; ties on the best
+ * score → ambiguous.
+ *
+ * Optimisation: we only score candidates anchored at line boundaries.
+ * Sub-line windows produce essentially-random ratios and waste cycles.
+ */
+export function tryEditDistance(source, search, replace, opts = {}) {
+    const minRatio = clamp(opts.minRatio ?? DEFAULT_MIN_RATIO, 0, 1);
+    const lengthFlex = clamp(opts.lengthFlex ?? DEFAULT_LENGTH_FLEX, 0, 0.5);
+    if (source.length === 0) {
+        return { kind: 'no_match', detail: 'edit-distance: empty source' };
+    }
+    const lineOffsets = computeLineOffsets(source);
+    // Append the final EOF offset so the slice window covers the tail.
+    const anchors = [...lineOffsets];
+    if (anchors[anchors.length - 1] !== source.length)
+        anchors.push(source.length);
+    const minLen = Math.max(1, Math.floor(search.length * (1 - lengthFlex)));
+    const maxLen = Math.max(minLen, Math.ceil(search.length * (1 + lengthFlex)));
+    let bestRatio = 0;
+    let bestStart = -1;
+    let bestEnd = -1;
+    let bestCount = 0;
+    for (let i = 0; i < anchors.length; i += 1) {
+        const start = anchors[i] ?? 0;
+        for (let j = i + 1; j < anchors.length; j += 1) {
+            const end = anchors[j] ?? source.length;
+            const len = end - start;
+            if (len < minLen)
+                continue;
+            if (len > maxLen)
+                break; // anchors monotonic → no point continuing inner loop
+            const slice = source.slice(start, end);
+            const ratio = lcsRatio(slice, search);
+            if (ratio > bestRatio + 1e-9) {
+                bestRatio = ratio;
+                bestStart = start;
+                bestEnd = end;
+                bestCount = 1;
+            }
+            else if (Math.abs(ratio - bestRatio) <= 1e-9 && bestRatio >= minRatio) {
+                bestCount += 1;
+            }
+        }
+    }
+    if (bestRatio < minRatio || bestStart === -1) {
+        return { kind: 'no_match', detail: `edit-distance: best ratio ${bestRatio.toFixed(3)} < ${minRatio}` };
+    }
+    if (bestCount > 1) {
+        return { kind: 'ambiguous', tier: 'edit-distance', candidateCount: bestCount, detail: `edit-distance: ${bestCount} candidates at ratio ${bestRatio.toFixed(3)}` };
+    }
+    const after = source.slice(0, bestStart) + replace + source.slice(bestEnd);
+    return {
+        kind: 'matched',
+        tier: 'edit-distance',
+        after,
+        score: bestRatio,
+        startOffset: bestStart,
+        endOffset: bestEnd,
+    };
+}
+// ---------- helpers ----------
+/** Clamp x to [lo, hi]. Returns NaN-safe value (NaN → lo). */
+function clamp(x, lo, hi) {
+    if (!Number.isFinite(x))
+        return lo;
+    if (x < lo)
+        return lo;
+    if (x > hi)
+        return hi;
+    return x;
+}
+/**
+ * Split a string on line terminators, KEEPING the terminator on each
+ * line. So `"a\nb\n"` → `["a\n", "b\n"]`. A trailing line without a
+ * terminator is preserved as its own entry: `"a\nb"` → `["a\n", "b"]`.
+ *
+ * This matters because tier 1 compares line-by-line and rebuilds the
+ * buffer by joining without an extra separator — discarding the line
+ * terminator would corrupt CRLF / LF source files on rebuild.
+ */
+export function splitLinesKeepEnds(s) {
+    if (s.length === 0)
+        return [];
+    const out = [];
+    let start = 0;
+    for (let i = 0; i < s.length; i += 1) {
+        const ch = s.charCodeAt(i);
+        if (ch === 10 /* \n */) {
+            out.push(s.slice(start, i + 1));
+            start = i + 1;
+        }
+    }
+    if (start < s.length)
+        out.push(s.slice(start));
+    return out;
+}
+/**
+ * Split a line into `{ prefix, rest }` where `prefix` is the
+ * contiguous leading whitespace (spaces + tabs only — newlines are
+ * never leading WS in a single line).
+ */
+export function splitLeadingWs(line) {
+    let i = 0;
+    while (i < line.length) {
+        const ch = line.charCodeAt(i);
+        if (ch === 32 /* space */ || ch === 9 /* tab */)
+            i += 1;
+        else
+            break;
+    }
+    return { prefix: line.slice(0, i), rest: line.slice(i) };
+}
+/**
+ * Compute the line-start offsets for `s`. Index `i` holds the byte
+ * offset of the start of line `i`; line 0 always starts at 0. Used by
+ * tiers 1 + 3 to compute slice bounds without re-scanning.
+ */
+export function computeLineOffsets(s) {
+    const out = [0];
+    for (let i = 0; i < s.length; i += 1) {
+        if (s.charCodeAt(i) === 10)
+            out.push(i + 1);
+    }
+    return out;
+}
+/**
+ * Return the prefix delta from `searchPrefix` to `sourcePrefix` if
+ * `sourcePrefix` is a prefix-superset of `searchPrefix`, else null.
+ *
+ * Examples:
+ *  searchPrefix="" sourcePrefix="   " → "   "
+ *  searchPrefix=" " sourcePrefix="   " → " "
+ *  searchPrefix=" " sourcePrefix="\t" → null (different WS char)
+ *  searchPrefix="   " sourcePrefix=" " → null (search deeper than source)
+ */
+export function computePrefixDelta(sourcePrefix, searchPrefix) {
+    if (!sourcePrefix.endsWith(searchPrefix)) {
+        // We allow the search prefix to be a SUFFIX of the source prefix —
+        // i.e. the source has additional leading indent. `endsWith` is the
+        // right check because we want `sourcePrefix = delta + searchPrefix`.
+        return null;
+    }
+    return sourcePrefix.slice(0, sourcePrefix.length - searchPrefix.length);
+}
+/**
+ * Split a SEARCH or REPLACE block on ellipsis markers — a line whose
+ * trimmed content is exactly `...`. Returns the chunks between markers
+ * (the markers themselves are dropped). A block with no marker returns
+ * a single-element array (caller treats that as "no ellipsis tier").
+ *
+ * Examples:
+ *  "head\n...\ntail"          → ["head\n", "\ntail"]
+ *  "head\n...\nmid\n...\ntail" → ["head\n", "\nmid\n", "\ntail"]
+ *  "no markers here"          → ["no markers here"]
+ */
+export function splitOnEllipsis(s) {
+    const lines = splitLinesKeepEnds(s);
+    const chunks = [];
+    let current = '';
+    let foundMarker = false;
+    for (const line of lines) {
+        // Trim line content (without the terminator) for marker detection.
+        const noTerm = line.replace(/\r?\n$/, '');
+        if (noTerm.trim() === '...') {
+            foundMarker = true;
+            chunks.push(current);
+            current = '';
+            continue;
+        }
+        current += line;
+    }
+    chunks.push(current);
+    if (!foundMarker)
+        return [s];
+    return chunks;
+}
+/**
+ * Enumerate every start offset where `needle` appears in `haystack`,
+ * including overlapping positions. Caller passes `maxNeeded` so we can
+ * short-circuit as soon as we have enough hits to make the uniqueness
+ * decision (the typical case wants `maxNeeded = 2` — one for the match,
+ * two to prove ambiguity).
+ *
+ * Triple-review P1-2 — the previous `indexOf(needle, lastIdx +
+ * needle.length)` stride skipped overlapping matches. Stride-by-1
+ * scanning catches "aaa" inside "aaaa" (matches at indices 0 and 1).
+ * We deliberately do NOT use `String.prototype.matchAll` with an
+ * escaped regex because (a) it allocates a RegExp per call and a
+ * MatchAll iterator with internal global state we then have to thread
+ * through escape() correctness, and (b) a malicious operator-supplied
+ * needle containing regex metacharacters could otherwise cause an
+ * UNescape mismatch — the loop here operates on raw characters so the
+ * metacharacter risk does not exist.
+ *
+ * Returns the byte offsets where each occurrence STARTS, in ascending
+ * order. Empty `needle` returns []; the caller is expected to gate on
+ * non-empty inputs upstream.
+ */
+export function enumerateMatches(haystack, needle, maxNeeded) {
+    if (needle.length === 0 || maxNeeded <= 0)
+        return [];
+    const out = [];
+    let pos = haystack.indexOf(needle, 0);
+    while (pos !== -1) {
+        out.push(pos);
+        if (out.length >= maxNeeded)
+            return out;
+        // Stride by 1, NOT by needle.length — overlapping matches are
+        // semantically distinct anchor candidates for the ellipsis tier.
+        pos = haystack.indexOf(needle, pos + 1);
+    }
+    return out;
+}
+/**
+ * Longest-common-subsequence length between `a` and `b`. O(|a|*|b|)
+ * time, O(min(|a|,|b|)) space via the standard two-row DP. Pure stdlib;
+ * no Levenshtein npm pkg per the constraint.
+ *
+ * Operates on CODE POINTS (16-bit code units, equivalent for our use
+ * because we never normalise unicode and the LLM-emitted text uses
+ * ASCII-heavy code paths).
+ */
+export function lcsLength(a, b) {
+    if (a.length === 0 || b.length === 0)
+        return 0;
+    // Ensure inner loop runs over the shorter string (smaller DP row).
+    const [outer, inner] = a.length <= b.length ? [b, a] : [a, b];
+    const n = inner.length;
+    // Two rows: previous + current. Reused across outer iterations.
+    let prev = new Uint32Array(n + 1);
+    let curr = new Uint32Array(n + 1);
+    for (let i = 0; i < outer.length; i += 1) {
+        const outerCh = outer.charCodeAt(i);
+        curr[0] = 0;
+        for (let j = 0; j < n; j += 1) {
+            if (outerCh === inner.charCodeAt(j)) {
+                curr[j + 1] = (prev[j] ?? 0) + 1;
+            }
+            else {
+                const top = prev[j + 1] ?? 0;
+                const left = curr[j] ?? 0;
+                curr[j + 1] = top >= left ? top : left;
+            }
+        }
+        const tmp = prev;
+        prev = curr;
+        curr = tmp;
+    }
+    return prev[n] ?? 0;
+}
+/**
+ * LCS-ratio defined as `(2 * lcs(a, b)) / (|a| + |b|)`. Range [0, 1].
+ * Equivalent to Python's `difflib.SequenceMatcher.ratio()` on the
+ * worst case where every chunk size = 1; close enough for the
+ * fuzzy-edit gate (we only care about the >= 0.8 threshold).
+ */
+export function lcsRatio(a, b) {
+    const total = a.length + b.length;
+    if (total === 0)
+        return 1;
+    return (2 * lcsLength(a, b)) / total;
+}
+//# sourceMappingURL=fuzzy-ladder.js.map

package/dist/core/edits/index.js

@@ -1,5 +1,5 @@
 /**
- * α6.6 diff escalation — public barrel.
+ * diff escalation — public barrel.
  *
  * Surface for callers (CLI integration, future engine adapters, tests).
  * Keeps the per-layer module path stable so β-tier additions (Layer D
@@ -7,6 +7,8 @@
  * fallback) can land without churn at the import sites.
  */
 export { applyLayerA, countOccurrences, } from './layer-a-apply.js';
+export { applyLayerAFuzzy, } from './layer-a-fuzzy-apply.js';
+export { tryFuzzyLadder, tryWhitespaceFlex, tryEllipsis, tryEditDistance, lcsLength, lcsRatio, splitLinesKeepEnds, splitLeadingWs, splitOnEllipsis, computeLineOffsets, computePrefixDelta, enumerateMatches, } from './fuzzy-ladder.js';
 export { applyLayerB, } from './layer-b-apply.js';
 export { applyLayerC, sha256OfUtf8, } from './layer-c-apply.js';
 export { applyLayerD, LayerDDeferredError, } from './layer-d-ast.js';