lacuna-cli 0.1.8 → 0.2.0

package/dist/lib/validate.js

@@ -13,11 +13,41 @@ export function hasTestFunctions(code) {
     const stripped = stripNonCode(code);
     return /\b(?:it|test)\s*(?:\.(?:each|concurrent|skip|only))?\s*\(/.test(stripped);
 }
-// If the runner output indicates "no tests found", replace it with a
-// clear instruction so the AI knows exactly what went wrong.
-export function enrichNoTestsError(output) {
-    if (!/no tests|0 tests?\b/i.test(output))
-        return output;
+// Returns true when the code contains placeholder test bodies — e.g. `{ // body }`.
+// A placeholder passes vitest (no assertions = no failures) but produces zero value.
+export function hasPlaceholderBodies(code) {
+    // Match an opening brace, optional whitespace/newline, a // comment that looks like
+    // a placeholder, then closing brace. Catches: { // body }, { // TODO }, { // implement }.
+    return /\{\s*\/\/\s*(body|todo|implement(?:ation)?|placeholder|stub|fill\s*in|your\s*code)\s*\}/i.test(code);
+}
+// Returns true when the runner output shows that zero tests were collected.
+// Distinct from hasTestFunctions (static check) — this checks actual runtime collection.
+// Handles:
+//   - Vitest summary "Tests  0 total" or "Tests  no tests"
+//   - Jest summary "Tests: 0 total"
+//   - Common "no tests found" / "found 0 tests" messages
+// NOTE: Vitest per-file listing lines like "foo.test.ts (0 test)" are NOT zero-test
+// signals — that interim count updates as tests resolve; the summary line is authoritative.
+// We do NOT match bare "0 test" (with word boundary) because of that false-positive.
+//
+// AUTHORITATIVE COUNT GUARD: if the summary reports ANY passed or failed test, tests WERE
+// collected — even if a failing test's name or assertion message happens to contain the
+// phrase "no tests found" / "found 0 tests". Those substrings are unanchored and would
+// otherwise false-positive on a run like "11 failed | 17 passed (28)". The pass/fail counts
+// come from the authoritative Tests summary line, so they override the substring match.
+export function isZeroTestsOutput(raw) {
+    if (parsePassCount(raw) > 0 || parseFailCount(raw) > 0)
+        return false;
+    return /Tests:?\s+(?:0\s+total|no tests)\b|no tests? found|found 0 tests/i.test(raw);
+}
+// If the runner output indicates "no tests found", replace it with a clear instruction
+// so the AI knows exactly what went wrong. The zero-tests decision is made on `rawOutput`
+// (the full runner output, which still carries the authoritative Tests summary line);
+// `extracted` is the already-trimmed failure text that gets returned/appended. Callers that
+// only have one string can omit `rawOutput` — it defaults to `extracted`.
+export function enrichNoTestsError(extracted, rawOutput = extracted) {
+    if (!isZeroTestsOutput(rawOutput))
+        return extracted;
     return ('ERROR: Vitest found 0 tests in this file. The file ran but had nothing to execute.\n\n' +
         'This means one of:\n' +
         '  1. You wrote only imports, types, or describe() blocks with no it()/test() inside\n' +
@@ -29,12 +59,7 @@ export function enrichNoTestsError(output) {
         '  })\n\n' +
         'DO NOT wrap tests inside a function. Put them directly inside describe() or at the top level.\n\n' +
         'Original runner output:\n' +
-        output);
-}
-// Returns true when the runner output shows that zero tests were collected.
-// Distinct from hasTestFunctions (static check) — this checks actual runtime collection.
-export function isZeroTestsOutput(raw) {
-    return /Tests:\s+0\s+total|no tests found|found 0 tests/i.test(raw);
+        extracted);
 }
 // Extracts the number of passing tests from the runner summary footer.
 // Targets the "Tests  N failed | M passed (total)" line specifically to avoid
@@ -48,6 +73,14 @@ export function parsePassCount(output) {
     const m = output.match(/(\d+)\s+passed/);
     return m ? parseInt(m[1], 10) : 0;
 }
+// Extracts the number of failing tests from the runner summary footer.
+// Anchored to the "Tests  N failed | M passed" line specifically — the word "failed"
+// appears in too many noise lines (per-test FAIL markers, stack frames) to match loosely.
+// Used alongside parsePassCount to prove tests were actually collected.
+export function parseFailCount(output) {
+    const summaryLine = output.match(/^\s*Tests\b[^\n]*?(\d+)\s+failed/m);
+    return summaryLine ? parseInt(summaryLine[1], 10) : 0;
+}
 // Strips leading prose/thinking lines from generated code output.
 // When a model bleeds reasoning into <code_output>, the file starts with fragments
 // like ", nothing else." or "I'll write the test now." before the real code begins.
@@ -394,4 +427,619 @@ export function buildRegressionMessage(initialError, currentError, baselinePass,
         `Do NOT modify tests that were already passing.\n` +
         `ONLY fix the test that was originally failing.`);
 }
+// Parses the model's patch output into a list of PatchOperation objects.
+//
+// Most operations have the form:
+//   // @@@ TYPE: "anchor"
+//   <content lines>
+//   // @@@ END
+//
+// REPLACE is different — it uses a WITH delimiter instead of an inline anchor:
+//   // @@@ REPLACE:
+//   <exact existing text to find, verbatim>
+//   // @@@ WITH:
+//   <replacement text>
+//   // @@@ END
+export function parsePatch(patchOutput) {
+    const ops = [];
+    const lines = patchOutput.split('\n');
+    // Capture the anchor either quoted ("name") or unquoted (name).
+    // Group 2 = quoted text, group 3 = unquoted text. DeepSeek and other models
+    // often drop the double-quotes, so we accept both forms.
+    const headerRe = /^\/\/ @@@ (REPLACE_TEST|DELETE_TEST|ADD_AFTER_DESCRIBE|ADD_IMPORT|ADD_AFTER_IMPORTS|REPLACE):\s*(?:"([^"]*)"|(.*\S))?/;
+    const withRe = /^\/\/ @@@ WITH:\s*$/;
+    const endRe = /^\/\/ @@@ END\s*$/;
+    let i = 0;
+    while (i < lines.length) {
+        const m = headerRe.exec(lines[i]);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const type = m[1];
+        i++;
+        if (type === 'REPLACE') {
+            // Read old text until // @@@ WITH:
+            const oldLines = [];
+            while (i < lines.length && !withRe.test(lines[i]) && !endRe.test(lines[i])) {
+                oldLines.push(lines[i]);
+                i++;
+            }
+            if (!withRe.test(lines[i] ?? '')) {
+                i++;
+                continue;
+            } // malformed — skip
+            i++; // skip // @@@ WITH:
+            const newLines = [];
+            while (i < lines.length && !endRe.test(lines[i])) {
+                newLines.push(lines[i]);
+                i++;
+            }
+            i++; // skip // @@@ END
+            let anchor = oldLines.join('\n');
+            let content = newLines.join('\n');
+            if (anchor.startsWith('\n'))
+                anchor = anchor.slice(1);
+            if (anchor.endsWith('\n'))
+                anchor = anchor.slice(0, -1);
+            if (content.startsWith('\n'))
+                content = content.slice(1);
+            if (content.endsWith('\n'))
+                content = content.slice(0, -1);
+            ops.push({ type, anchor, content });
+        }
+        else {
+            const anchor = (m[2] ?? m[3] ?? '').trim(); // quoted OR unquoted; ADD_IMPORT/ADD_AFTER_IMPORTS have no anchor
+            const contentLines = [];
+            while (i < lines.length && !endRe.test(lines[i])) {
+                contentLines.push(lines[i]);
+                i++;
+            }
+            i++; // skip // @@@ END
+            let content = contentLines.join('\n');
+            if (content.startsWith('\n'))
+                content = content.slice(1);
+            if (content.endsWith('\n'))
+                content = content.slice(0, -1);
+            ops.push({ type, anchor, content });
+        }
+    }
+    return ops;
+}
+// Finds the start and end character positions of `anchor` within `code`.
+// First tries exact match; if that fails, tries a line-by-line match that
+// trims trailing whitespace from each line (handles trailing spaces and CRLF files).
+// Returns the range in the ORIGINAL (un-normalized) code so the replacement is clean.
+function findAnchorRange(code, anchor) {
+    // Fast path: exact match
+    const exactIdx = code.indexOf(anchor);
+    if (exactIdx !== -1)
+        return { start: exactIdx, end: exactIdx + anchor.length };
+    // Fallback: trim trailing whitespace (including \r) on every line and re-compare.
+    // Handles trailing spaces left by editors and CRLF files (\r stripped by trimEnd).
+    const anchorLines = anchor.split('\n').map(l => l.trimEnd());
+    const codeLines = code.split('\n');
+    const n = anchorLines.length;
+    if (n === 0)
+        return null;
+    // Precompute byte offset of each line start — O(N) once, avoids O(N²) inner accumulation.
+    const lineStart = new Array(codeLines.length + 1);
+    lineStart[0] = 0;
+    for (let k = 0; k < codeLines.length; k++) {
+        lineStart[k + 1] = lineStart[k] + codeLines[k].length + 1; // +1 for the \n separator
+    }
+    for (let i = 0; i <= codeLines.length - n; i++) {
+        if (codeLines[i].trimEnd() !== anchorLines[0])
+            continue;
+        let match = true;
+        for (let j = 1; j < n; j++) {
+            if (codeLines[i + j].trimEnd() !== anchorLines[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (!match)
+            continue;
+        const start = lineStart[i];
+        // end = start of line after the match minus the \n, i.e. the span of the matched lines joined
+        const end = start + codeLines.slice(i, i + n).join('\n').length;
+        return { start, end };
+    }
+    return null;
+}
+// Finds the end of an it()/test()/describe() call starting at `startIdx` in `code`.
+// `startIdx` must point to the opening `(` of the call.
+// Returns the index just past the closing `)` (and optional `;`), or -1 on failure.
+//
+// Strategy: skip the string argument(s), find the function body `{`, track brace depth
+// until it returns to 0, then consume the closing `)` and optional `;`.
+// We do a simplified scan that handles string literals and template literals to avoid
+// false brace counts inside quoted text.
+function findCallEnd(code, startIdx) {
+    let i = startIdx; // points at the `(` of the call
+    let parenDepth = 0;
+    let braceDepth = 0;
+    let foundBrace = false;
+    while (i < code.length) {
+        const ch = code[i];
+        // Skip string literals to avoid false brace/paren counts inside strings
+        if (ch === '"' || ch === "'") {
+            const q = ch;
+            i++;
+            while (i < code.length) {
+                if (code[i] === '\\') {
+                    i += 2;
+                    continue;
+                }
+                if (code[i] === q) {
+                    i++;
+                    break;
+                }
+                i++;
+            }
+            continue;
+        }
+        if (ch === '`') {
+            i++;
+            while (i < code.length) {
+                if (code[i] === '\\') {
+                    i += 2;
+                    continue;
+                }
+                if (code[i] === '`') {
+                    i++;
+                    break;
+                }
+                // Skip ${...} expressions inside template literals (simplified: track braces)
+                if (code[i] === '$' && code[i + 1] === '{') {
+                    i += 2;
+                    let tDepth = 1;
+                    while (i < code.length && tDepth > 0) {
+                        if (code[i] === '{')
+                            tDepth++;
+                        else if (code[i] === '}')
+                            tDepth--;
+                        i++;
+                    }
+                    continue;
+                }
+                i++;
+            }
+            continue;
+        }
+        if (ch === '{') {
+            foundBrace = true;
+            braceDepth++;
+            i++;
+            continue;
+        }
+        if (ch === '}') {
+            if (foundBrace) {
+                braceDepth--;
+                if (braceDepth === 0) {
+                    // We've closed the function body. Now consume the closing `)` and optional `;`
+                    i++; // move past `}`
+                    // skip whitespace/newlines
+                    while (i < code.length && (code[i] === ' ' || code[i] === '\t' || code[i] === '\n' || code[i] === '\r'))
+                        i++;
+                    if (i < code.length && code[i] === ')') {
+                        i++; // consume `)`
+                        if (i < code.length && code[i] === ';')
+                            i++; // consume optional `;`
+                    }
+                    return i;
+                }
+            }
+            i++;
+            continue;
+        }
+        if (!foundBrace) {
+            // Before the opening brace we still count parens to handle nested calls in args
+            if (ch === '(')
+                parenDepth++;
+            else if (ch === ')') {
+                parenDepth--;
+                // If we hit -1 depth without ever finding a brace this is a call with no body (unlikely for tests)
+                if (parenDepth < 0)
+                    return -1;
+            }
+        }
+        i++;
+    }
+    return -1;
+}
+// Applies a list of PatchOperation objects to `existingCode` in order.
+// Returns the modified string, or null if any anchor cannot be located.
+export function applyPatch(existingCode, ops) {
+    let code = existingCode;
+    for (const op of ops) {
+        if (op.type === 'REPLACE') {
+            // General text replacement — same mechanism as the Edit tool.
+            // anchor = exact old text, content = replacement. First occurrence only.
+            // Falls back to trailing-whitespace-normalized line matching so that minor
+            // formatting differences (trailing spaces, CRLF files) don't cause failures.
+            const range = findAnchorRange(code, op.anchor);
+            if (!range)
+                return null;
+            code = code.slice(0, range.start) + op.content + code.slice(range.end);
+        }
+        else if (op.type === 'REPLACE_TEST' || op.type === 'DELETE_TEST') {
+            const anchor = op.anchor;
+            // Try all four quote/keyword combos
+            const candidates = [
+                `it("${anchor}"`,
+                `it('${anchor}'`,
+                `test("${anchor}"`,
+                `test('${anchor}'`,
+            ];
+            let foundIdx = -1;
+            for (const c of candidates) {
+                const idx = code.indexOf(c);
+                if (idx !== -1) {
+                    foundIdx = idx;
+                    break;
+                }
+            }
+            if (foundIdx === -1)
+                return null;
+            // Find the opening `(` of the call — it's right after `it` or `test`
+            const parenIdx = code.indexOf('(', foundIdx);
+            if (parenIdx === -1)
+                return null;
+            const callEnd = findCallEnd(code, parenIdx);
+            if (callEnd === -1)
+                return null;
+            if (op.type === 'REPLACE_TEST') {
+                code = code.slice(0, foundIdx) + op.content + code.slice(callEnd);
+            }
+            else {
+                // DELETE_TEST: also remove an immediately preceding blank line
+                let removeStart = foundIdx;
+                if (removeStart > 0 && code[removeStart - 1] === '\n') {
+                    // Check if the line before is blank
+                    const prevNewline = code.lastIndexOf('\n', removeStart - 2);
+                    const prevLine = code.slice(prevNewline + 1, removeStart - 1);
+                    if (prevLine.trim() === '')
+                        removeStart = prevNewline + 1;
+                }
+                code = code.slice(0, removeStart) + code.slice(callEnd);
+            }
+        }
+        else if (op.type === 'ADD_AFTER_DESCRIBE') {
+            const anchor = op.anchor;
+            const candidates = [
+                `describe("${anchor}"`,
+                `describe('${anchor}'`,
+            ];
+            let foundIdx = -1;
+            for (const c of candidates) {
+                const idx = code.indexOf(c);
+                if (idx !== -1) {
+                    foundIdx = idx;
+                    break;
+                }
+            }
+            if (foundIdx === -1)
+                return null;
+            // Find the opening `(` of the describe call
+            const parenIdx = code.indexOf('(', foundIdx);
+            if (parenIdx === -1)
+                return null;
+            // Walk from parenIdx to find the LAST closing `})` of the describe block.
+            // We track brace depth from the first `{` we encounter inside the describe args.
+            let i = parenIdx;
+            let braceDepth = 0;
+            let lastClosePos = -1; // position of the `}` that closes the describe body
+            // Skip string literal for the describe name argument
+            // The describe call looks like: describe("name", () => { ... })
+            // We need to find the function body brace
+            let foundBrace = false;
+            while (i < code.length) {
+                const ch = code[i];
+                // Skip string literals
+                if (ch === '"' || ch === "'") {
+                    const q = ch;
+                    i++;
+                    while (i < code.length) {
+                        if (code[i] === '\\') {
+                            i += 2;
+                            continue;
+                        }
+                        if (code[i] === q) {
+                            i++;
+                            break;
+                        }
+                        i++;
+                    }
+                    continue;
+                }
+                if (ch === '`') {
+                    i++;
+                    while (i < code.length) {
+                        if (code[i] === '\\') {
+                            i += 2;
+                            continue;
+                        }
+                        if (code[i] === '`') {
+                            i++;
+                            break;
+                        }
+                        if (code[i] === '$' && code[i + 1] === '{') {
+                            i += 2;
+                            let tDepth = 1;
+                            while (i < code.length && tDepth > 0) {
+                                if (code[i] === '{')
+                                    tDepth++;
+                                else if (code[i] === '}')
+                                    tDepth--;
+                                i++;
+                            }
+                            continue;
+                        }
+                        i++;
+                    }
+                    continue;
+                }
+                if (ch === '{') {
+                    foundBrace = true;
+                    braceDepth++;
+                    i++;
+                    continue;
+                }
+                if (ch === '}') {
+                    if (foundBrace) {
+                        braceDepth--;
+                        if (braceDepth === 0) {
+                            lastClosePos = i;
+                            break;
+                        }
+                    }
+                    i++;
+                    continue;
+                }
+                i++;
+            }
+            if (lastClosePos === -1)
+                return null;
+            // Insert content immediately before the closing `}`
+            // Add a newline after content so the `}` is on its own line
+            const insertion = '\n' + op.content + '\n';
+            code = code.slice(0, lastClosePos) + insertion + code.slice(lastClosePos);
+        }
+        else if (op.type === 'ADD_IMPORT') {
+            // Find the last `import ` line in the file
+            const lines = code.split('\n');
+            let lastImportLineIdx = -1;
+            for (let idx = 0; idx < lines.length; idx++) {
+                if (/^\s*import\s/.test(lines[idx]))
+                    lastImportLineIdx = idx;
+            }
+            const importLines = op.content.split('\n');
+            if (lastImportLineIdx === -1) {
+                lines.unshift(...importLines);
+            }
+            else {
+                lines.splice(lastImportLineIdx + 1, 0, ...importLines);
+            }
+            code = lines.join('\n');
+        }
+        else if (op.type === 'ADD_AFTER_IMPORTS') {
+            // Like ADD_IMPORT but inserts a blank line before the block — for vi.mock() calls
+            // and other module-level statements that follow imports
+            const lines = code.split('\n');
+            let lastImportLineIdx = -1;
+            for (let idx = 0; idx < lines.length; idx++) {
+                if (/^\s*import\s/.test(lines[idx]))
+                    lastImportLineIdx = idx;
+            }
+            const contentLines = ['', ...op.content.split('\n')];
+            if (lastImportLineIdx === -1) {
+                lines.unshift(...contentLines);
+            }
+            else {
+                lines.splice(lastImportLineIdx + 1, 0, ...contentLines);
+            }
+            code = lines.join('\n');
+        }
+    }
+    // Collapse gaps left by DELETE_TEST: runs of 3+ newlines (2+ consecutive blank lines)
+    // down to exactly 2 newlines (1 blank line). Safe — never affects content.
+    code = code.replace(/\n{3,}/g, '\n\n');
+    // Remove describe blocks that became empty shells (no it/test calls anywhere inside).
+    // Repeat until stable — outer empties are caught after inner empties are removed.
+    code = removeEmptyDescribeBlocks(code);
+    return code;
+}
+// Removes describe() blocks whose body contains no it() or test() calls at any depth.
+// Iterates until stable to handle nested empty blocks (inner removed first, then outer).
+function removeEmptyDescribeBlocks(code) {
+    let prev = '';
+    while (code !== prev) {
+        prev = code;
+        const lines = code.split('\n');
+        const out = [];
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            if (/^\s*describe\s*\(/.test(line) && line.trimEnd().endsWith('{')) {
+                // Collect the full block by tracking brace depth.
+                // Note: braces in string literals may cause a false depth count, but that
+                // only risks keeping a block we should remove — never deleting a live one,
+                // because we require it()/test() to be absent in ALL collected lines.
+                let depth = 1;
+                let j = i + 1;
+                const bodyLines = [];
+                while (j < lines.length && depth > 0) {
+                    const l = lines[j];
+                    for (const ch of l) {
+                        if (ch === '{')
+                            depth++;
+                        else if (ch === '}')
+                            depth--;
+                    }
+                    if (depth > 0)
+                        bodyLines.push(l);
+                    j++;
+                }
+                const hasTests = bodyLines.some(l => /\b(?:it|test)\s*\(/.test(l));
+                if (!hasTests) {
+                    // Skip the whole block (opening line through closing line)
+                    i = j;
+                    // Consume a trailing blank line so deletions don't stack up
+                    if (i < lines.length && !lines[i].trim())
+                        i++;
+                    continue;
+                }
+            }
+            out.push(line);
+            i++;
+        }
+        code = out.join('\n');
+    }
+    return code;
+}
+// Convenience wrapper: parses then applies. Returns null if no ops parsed or apply fails.
+export function tryApplyPatch(existingCode, patchOutput) {
+    const ops = parsePatch(patchOutput);
+    if (ops.length === 0)
+        return null;
+    return applyPatch(existingCode, ops);
+}
+// Like tryApplyPatch but surfaces which operation failed, so callers can build
+// a useful error message pointing the model at the exact anchor that didn't match.
+export function tryApplyPatchWithDiag(existingCode, patchOutput) {
+    const ops = parsePatch(patchOutput);
+    if (ops.length === 0)
+        return { ok: false, failedOp: null, opsCount: 0 };
+    let code = existingCode;
+    for (const op of ops) {
+        const result = applyPatch(code, [op]);
+        if (result === null)
+            return { ok: false, failedOp: op, opsCount: ops.length };
+        code = result;
+    }
+    return { ok: true, result: code };
+}
+export function parseMocksPatch(patchOutput) {
+    const ops = [];
+    const lines = patchOutput.split('\n');
+    const headerRe = /^\/\/ @@@ (REPLACE|APPEND_EXPORT|ADD_TO_BEFOREEACH):\s*$/;
+    const withRe = /^\/\/ @@@ WITH:\s*$/;
+    const endRe = /^\/\/ @@@ END\s*$/;
+    let i = 0;
+    while (i < lines.length) {
+        const m = headerRe.exec(lines[i]);
+        if (!m) {
+            i++;
+            continue;
+        }
+        const type = m[1];
+        i++;
+        if (type === 'REPLACE') {
+            const oldLines = [];
+            while (i < lines.length && !withRe.test(lines[i]) && !endRe.test(lines[i])) {
+                oldLines.push(lines[i]);
+                i++;
+            }
+            if (!withRe.test(lines[i] ?? '')) {
+                i++;
+                continue;
+            }
+            i++; // skip // @@@ WITH:
+            const newLines = [];
+            while (i < lines.length && !endRe.test(lines[i])) {
+                newLines.push(lines[i]);
+                i++;
+            }
+            i++; // skip // @@@ END
+            let oldText = oldLines.join('\n');
+            let newText = newLines.join('\n');
+            if (oldText.startsWith('\n'))
+                oldText = oldText.slice(1);
+            if (oldText.endsWith('\n'))
+                oldText = oldText.slice(0, -1);
+            if (newText.startsWith('\n'))
+                newText = newText.slice(1);
+            if (newText.endsWith('\n'))
+                newText = newText.slice(0, -1);
+            ops.push({ type, oldText, newText });
+        }
+        else {
+            // APPEND_EXPORT and ADD_TO_BEFOREEACH — just content, no WITH: block
+            const contentLines = [];
+            while (i < lines.length && !endRe.test(lines[i])) {
+                contentLines.push(lines[i]);
+                i++;
+            }
+            i++; // skip // @@@ END
+            let newText = contentLines.join('\n');
+            if (newText.startsWith('\n'))
+                newText = newText.slice(1);
+            if (newText.endsWith('\n'))
+                newText = newText.slice(0, -1);
+            ops.push({ type, oldText: '', newText });
+        }
+    }
+    return ops;
+}
+export function applyMocksPatch(existing, ops) {
+    let code = existing;
+    const failedOps = [];
+    for (const op of ops) {
+        if (op.type === 'REPLACE') {
+            const range = findAnchorRange(code, op.oldText);
+            if (!range) {
+                failedOps.push(op);
+                continue;
+            }
+            code = code.slice(0, range.start) + op.newText + code.slice(range.end);
+        }
+        else if (op.type === 'APPEND_EXPORT') {
+            // Insert before the last beforeEach block, or at end of file if none
+            const beforeEachIdx = code.lastIndexOf('\nbeforeEach(');
+            if (beforeEachIdx !== -1) {
+                code = code.slice(0, beforeEachIdx) + '\n\n' + op.newText.trim() + code.slice(beforeEachIdx);
+            }
+            else {
+                code = code.trimEnd() + '\n\n' + op.newText.trim();
+            }
+        }
+        else if (op.type === 'ADD_TO_BEFOREEACH') {
+            // Find the last beforeEach and insert before its closing brace
+            const beIdx = code.lastIndexOf('\nbeforeEach(');
+            if (beIdx === -1) {
+                failedOps.push(op);
+                continue;
+            }
+            // Find the closing }) of that beforeEach by tracking brace depth
+            let depth = 0;
+            let closeIdx = -1;
+            for (let i = beIdx + 1; i < code.length; i++) {
+                if (code[i] === '{')
+                    depth++;
+                else if (code[i] === '}') {
+                    depth--;
+                    if (depth === 0) {
+                        closeIdx = i;
+                        break;
+                    }
+                }
+            }
+            if (closeIdx === -1) {
+                failedOps.push(op);
+                continue;
+            }
+            const indent = '  ';
+            const lines = op.newText.trim().split('\n').map(l => indent + l).join('\n');
+            code = code.slice(0, closeIdx) + '\n' + lines + '\n' + code.slice(closeIdx);
+        }
+    }
+    return { result: code, failedOps };
+}
+export function tryApplyMocksPatch(existing, patchOutput) {
+    const ops = parseMocksPatch(patchOutput);
+    if (ops.length === 0)
+        return null;
+    return applyMocksPatch(existing, ops);
+}
 //# sourceMappingURL=validate.js.map