@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.1

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

@@ -1,650 +0,0 @@
-/**
- * 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). independent implementation
- * 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,19 +0,0 @@
-/**
- * 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
- * implementation, conflict resolution UI, unified-diff `git apply`
- * 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';
-export { MarkerParseError, detectFamily, parseMarkers, } from './marker-parser.js';
-export { dispatchEdit, resolveFamily, } from './dispatch.js';
-export { EDIT_FORMAT_MATRIX, pickEditFormat, } from './format-matrix.js';
-export { detectEditFormat, detectModelFamily, familyDefaultChain, renderEditFormatHint, } from './format-detector.js';
-//# sourceMappingURL=index.js.map