@jsonstudio/llms 0.6.938 → 0.6.1164

package/dist/tools/apply-patch/patch-text/context-diff.js

@@ -0,0 +1,173 @@
+export const convertContextDiffToApplyPatch = (text) => {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const patchLines = ['*** Begin Patch'];
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i] ?? '';
+        if (!line.startsWith('*** ')) {
+            i += 1;
+            continue;
+        }
+        const oldHeader = line.slice(4).trim();
+        const newHeaderLine = lines[i + 1] ?? '';
+        if (!newHeaderLine.startsWith('--- ')) {
+            i += 1;
+            continue;
+        }
+        const newHeader = newHeaderLine.slice(4).trim();
+        const filePathRaw = (newHeader && newHeader !== '/dev/null' ? newHeader : oldHeader) || '';
+        const filePath = filePathRaw.split('\t')[0]?.trim() || '';
+        if (!filePath) {
+            i += 2;
+            continue;
+        }
+        i += 2;
+        const hunks = [];
+        while (i < lines.length) {
+            const marker = lines[i] ?? '';
+            if (marker.startsWith('*** ') && (lines[i + 1] ?? '').startsWith('--- ')) {
+                break; // next file header
+            }
+            if (marker.startsWith('***************')) {
+                i += 1;
+                const oldRangeHeader = lines[i] ?? '';
+                if (!oldRangeHeader.startsWith('*** ')) {
+                    continue;
+                }
+                const oldRangeMatch = oldRangeHeader.match(/^\*\*\*\s+(\d+)(?:,(\d+))?\s+\*{4}\s*$/);
+                i += 1;
+                const oldLines = [];
+                while (i < lines.length && !(lines[i] ?? '').startsWith('--- ')) {
+                    const l = lines[i] ?? '';
+                    if (l.startsWith('***************'))
+                        break;
+                    if (l.startsWith('*** ') && (lines[i + 1] ?? '').startsWith('--- '))
+                        break;
+                    oldLines.push(l);
+                    i += 1;
+                }
+                const newRangeHeader = lines[i] ?? '';
+                if (!newRangeHeader.startsWith('--- ')) {
+                    continue;
+                }
+                const newRangeMatch = newRangeHeader.match(/^---\s+(\d+)(?:,(\d+))?\s+-{4}\s*$/);
+                i += 1;
+                const newLines = [];
+                while (i < lines.length) {
+                    const l = lines[i] ?? '';
+                    if (l.startsWith('***************'))
+                        break;
+                    if (l.startsWith('*** ') && (lines[i + 1] ?? '').startsWith('--- '))
+                        break;
+                    newLines.push(l);
+                    i += 1;
+                }
+                const oldStart = oldRangeMatch ? Number.parseInt(oldRangeMatch[1], 10) : undefined;
+                const oldEnd = oldRangeMatch && oldRangeMatch[2] ? Number.parseInt(oldRangeMatch[2], 10) : oldStart;
+                const newStart = newRangeMatch ? Number.parseInt(newRangeMatch[1], 10) : undefined;
+                const newEnd = newRangeMatch && newRangeMatch[2] ? Number.parseInt(newRangeMatch[2], 10) : newStart;
+                const oldCount = oldStart && oldEnd && Number.isFinite(oldStart) && Number.isFinite(oldEnd)
+                    ? Math.max(0, oldEnd - oldStart + 1)
+                    : undefined;
+                const newCount = newStart && newEnd && Number.isFinite(newStart) && Number.isFinite(newEnd)
+                    ? Math.max(0, newEnd - newStart + 1)
+                    : undefined;
+                hunks.push({
+                    oldStart,
+                    oldCount,
+                    newStart,
+                    newCount,
+                    oldLines,
+                    newLines
+                });
+                continue;
+            }
+            i += 1;
+        }
+        if (!hunks.length) {
+            continue;
+        }
+        patchLines.push(`*** Update File: ${filePath}`);
+        const decodeContextLine = (raw) => {
+            if (raw === undefined || raw === null)
+                return null;
+            const lineText = String(raw);
+            const lead = lineText[0] ?? '';
+            const candidateKinds = {
+                ' ': 'context',
+                '!': 'delete',
+                '-': 'delete',
+                '+': 'add'
+            };
+            const kind = candidateKinds[lead];
+            const content = kind
+                ? (() => {
+                    let rest = lineText.slice(1);
+                    if (rest.startsWith(' '))
+                        rest = rest.slice(1);
+                    return rest;
+                })()
+                : lineText;
+            return { kind: kind ?? 'context', text: content };
+        };
+        for (const hunk of hunks) {
+            patchLines.push('@@');
+            const oldOps = hunk.oldLines.map(decodeContextLine).filter(Boolean);
+            const newOpsRaw = hunk.newLines.map(decodeContextLine).filter(Boolean);
+            // In new-half, "!" denotes replacement (add side) rather than delete.
+            const newOps = newOpsRaw.map((op) => {
+                if (!op)
+                    return op;
+                if (op.kind === 'delete') {
+                    // Interpret '!' (mapped to delete) as add for new-half.
+                    return { kind: 'add', text: op.text };
+                }
+                return op;
+            });
+            let oi = 0;
+            let ni = 0;
+            while (oi < oldOps.length || ni < newOps.length) {
+                const o = oi < oldOps.length ? oldOps[oi] : null;
+                const n = ni < newOps.length ? newOps[ni] : null;
+                if (o && n && o.kind === 'context' && n.kind === 'context' && o.text === n.text) {
+                    patchLines.push(` ${o.text}`);
+                    oi += 1;
+                    ni += 1;
+                    continue;
+                }
+                if (o && o.kind === 'delete') {
+                    patchLines.push(`-${o.text}`);
+                    oi += 1;
+                    if (n && n.kind === 'add') {
+                        patchLines.push(`+${n.text}`);
+                        ni += 1;
+                    }
+                    continue;
+                }
+                if (n && n.kind === 'add') {
+                    patchLines.push(`+${n.text}`);
+                    ni += 1;
+                    continue;
+                }
+                if (o && o.kind === 'context') {
+                    patchLines.push(` ${o.text}`);
+                    oi += 1;
+                    continue;
+                }
+                if (n && n.kind === 'context') {
+                    patchLines.push(` ${n.text}`);
+                    ni += 1;
+                    continue;
+                }
+                // Fallback: advance to avoid infinite loops.
+                if (o)
+                    oi += 1;
+                if (n)
+                    ni += 1;
+            }
+        }
+    }
+    patchLines.push('*** End Patch');
+    const out = patchLines.join('\n').trim();
+    return out.includes('*** Update File:') ? out : null;
+};

package/dist/tools/apply-patch/patch-text/git-diff.d.ts

@@ -0,0 +1 @@
+export declare const convertGitDiffToApplyPatch: (text: string) => string | null;

package/dist/tools/apply-patch/patch-text/git-diff.js

@@ -0,0 +1,138 @@
+export const convertGitDiffToApplyPatch = (text) => {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const files = [];
+    let current = null;
+    let sawDiff = false;
+    const flush = () => {
+        if (!current)
+            return;
+        if (current.path && current.kind === 'delete') {
+            files.push(current);
+            current = null;
+            return;
+        }
+        // Include rename-only diffs (no hunks) when we have a move target.
+        if (current.path && (current.lines.length || current.moveTo)) {
+            files.push(current);
+        }
+        current = null;
+    };
+    const extractPath = (value) => {
+        const v = String(value || '').trim();
+        if (!v)
+            return '';
+        const head = v.split('\t')[0] ?? v;
+        const m = String(head).trim().match(/^(?:a\/|b\/)?(.+)$/);
+        return (m && m[1] ? m[1] : String(head)).trim();
+    };
+    for (const line of lines) {
+        const diffMatch = line.match(/^diff --git\s+a\/(.+?)\s+b\/(.+)$/);
+        if (diffMatch) {
+            sawDiff = true;
+            flush();
+            current = {
+                path: extractPath(diffMatch[2]),
+                kind: 'update',
+                lines: [],
+                oldPath: extractPath(diffMatch[1]),
+                newPath: extractPath(diffMatch[2])
+            };
+            continue;
+        }
+        if (!current)
+            continue;
+        if (line.startsWith('GIT binary patch') || line.startsWith('Binary files ')) {
+            current.binary = true;
+            continue;
+        }
+        const delMatch = line.match(/^deleted file mode\s+/);
+        const newMatch = line.match(/^new file mode\s+/);
+        if (delMatch) {
+            current.kind = 'delete';
+            continue;
+        }
+        if (newMatch) {
+            current.kind = 'add';
+            continue;
+        }
+        if (line.startsWith('rename from ')) {
+            const p = extractPath(line.slice('rename from '.length));
+            if (p)
+                current.oldPath = p;
+            continue;
+        }
+        if (line.startsWith('rename to ')) {
+            const p = extractPath(line.slice('rename to '.length));
+            if (p) {
+                current.newPath = p;
+                current.moveTo = p;
+            }
+            continue;
+        }
+        if (line.startsWith('--- ')) {
+            const p = extractPath(line.slice(4));
+            if (p) {
+                current.oldPath = p;
+                if (p === '/dev/null')
+                    current.kind = 'add';
+            }
+            continue;
+        }
+        if (line.startsWith('+++ ')) {
+            const p = extractPath(line.slice(4));
+            if (p) {
+                current.newPath = p;
+                if (p === '/dev/null')
+                    current.kind = 'delete';
+            }
+            continue;
+        }
+        if (line.startsWith('index ') || line.startsWith('similarity index ') || line.startsWith('dissimilarity index ')) {
+            continue;
+        }
+        if (line.startsWith('@@')) {
+            current.lines.push(line);
+            continue;
+        }
+        if (line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+            current.lines.push(line);
+            continue;
+        }
+    }
+    flush();
+    if (!sawDiff || files.length === 0)
+        return null;
+    if (files.some((f) => f.binary))
+        return null;
+    const out = ['*** Begin Patch'];
+    for (const file of files) {
+        const oldPath = typeof file.oldPath === 'string' ? file.oldPath : '';
+        const newPath = typeof file.newPath === 'string' ? file.newPath : '';
+        const resolvedPath = file.kind === 'add'
+            ? (newPath && newPath !== '/dev/null' ? newPath : file.path)
+            : file.kind === 'delete'
+                ? (oldPath && oldPath !== '/dev/null' ? oldPath : file.path)
+                : (file.moveTo && oldPath && oldPath !== '/dev/null'
+                    ? oldPath
+                    : (newPath && newPath !== '/dev/null' ? newPath : file.path));
+        if (file.kind === 'delete') {
+            out.push(`*** Delete File: ${resolvedPath}`);
+            continue;
+        }
+        if (file.kind === 'add') {
+            out.push(`*** Add File: ${resolvedPath}`);
+            for (const l of file.lines) {
+                if (l.startsWith('+'))
+                    out.push(l);
+            }
+            continue;
+        }
+        out.push(`*** Update File: ${resolvedPath}`);
+        if (file.moveTo && file.moveTo !== resolvedPath) {
+            out.push(`*** Move to: ${file.moveTo}`);
+        }
+        out.push(...file.lines);
+    }
+    out.push('*** End Patch');
+    return out.join('\n');
+};

package/dist/tools/apply-patch/patch-text/looks-like-patch.d.ts

@@ -0,0 +1 @@
+export declare const looksLikePatch: (text?: string) => boolean;

package/dist/tools/apply-patch/patch-text/looks-like-patch.js

@@ -0,0 +1,13 @@
+export const looksLikePatch = (text) => {
+    if (!text)
+        return false;
+    const t = text.trim();
+    if (!t)
+        return false;
+    return (t.includes('*** Begin Patch') ||
+        t.includes('*** Update File:') ||
+        t.includes('*** Add File:') ||
+        t.includes('*** Delete File:') ||
+        t.includes('diff --git') ||
+        /^(?:@@|\+\+\+\s|---\s)/m.test(t));
+};

package/dist/tools/apply-patch/patch-text/normalize.d.ts

@@ -0,0 +1,3 @@
+import { looksLikePatch } from './looks-like-patch.js';
+export declare const normalizeApplyPatchText: (raw: string) => string;
+export { looksLikePatch };

package/dist/tools/apply-patch/patch-text/normalize.js

@@ -0,0 +1,262 @@
+import { looksLikePatch } from './looks-like-patch.js';
+import { convertGitDiffToApplyPatch } from './git-diff.js';
+import { convertContextDiffToApplyPatch } from './context-diff.js';
+const normalizeBeginEndMarkers = (input) => {
+    try {
+        const lines = input.replace(/\r\n/g, '\n').split('\n');
+        if (!lines.length)
+            return input;
+        const first = String(lines[0] ?? '').trim().toLowerCase();
+        if (first.startsWith('*** begin patch')) {
+            lines[0] = '*** Begin Patch';
+        }
+        const lastIndex = lines.length - 1;
+        const last = String(lines[lastIndex] ?? '').trim().toLowerCase();
+        if (last.startsWith('*** end patch')) {
+            lines[lastIndex] = '*** End Patch';
+        }
+        return lines.join('\n');
+    }
+    catch {
+        return input;
+    }
+};
+const convertUnifiedDiffToApplyPatchIfPossible = (text) => {
+    try {
+        if (!text)
+            return null;
+        if (text.includes('diff --git')) {
+            return convertGitDiffToApplyPatch(text);
+        }
+        const minusMatch = text.match(/^---\s+(.*)$/m);
+        const plusMatch = text.match(/^\+\+\+\s+(.*)$/m);
+        if (!minusMatch || !plusMatch)
+            return null;
+        const rawMinus = (minusMatch[1] || '').split('\t')[0] || '';
+        const rawPlus = (plusMatch[1] || '').split('\t')[0] || '';
+        const normalizeHeaderPath = (value) => {
+            const v = String(value || '').trim();
+            if (!v)
+                return '';
+            const m = v.match(/^(?:a\/|b\/)?(.+)$/);
+            return (m && m[1] ? m[1] : v).trim();
+        };
+        const minusPath = normalizeHeaderPath(rawMinus);
+        const plusPath = normalizeHeaderPath(rawPlus);
+        const filePath = plusPath === '/dev/null' ? minusPath : plusPath;
+        if (!filePath)
+            return null;
+        const synthetic = `diff --git a/${filePath} b/${filePath}\n${text}`;
+        return convertGitDiffToApplyPatch(synthetic);
+    }
+    catch {
+        return null;
+    }
+};
+const stripCodeFences = (text) => {
+    const trimmed = text.trim();
+    // Only treat the entire payload as fenced when it *starts* with a code fence.
+    // Patch bodies (especially added Markdown files) may legitimately contain ``` blocks;
+    // we must not strip those.
+    if (!trimmed.startsWith('```'))
+        return text;
+    const fenceRe = /^```(?:diff|patch|apply_patch|text|json)?[ \t]*\n([\s\S]*?)\n```/gmi;
+    const candidates = [];
+    let match = null;
+    while ((match = fenceRe.exec(trimmed))) {
+        if (match[1])
+            candidates.push(match[1].trim());
+    }
+    if (!candidates.length)
+        return text;
+    for (const candidate of candidates) {
+        if (candidate.includes('*** Begin Patch') ||
+            candidate.includes('*** Update File:') ||
+            candidate.includes('diff --git')) {
+            return candidate;
+        }
+    }
+    return candidates[0] ?? text;
+};
+const decodeEscapedNewlinesIfNeeded = (value) => {
+    try {
+        if (!value)
+            return value;
+        if (value.includes('\n'))
+            return value;
+        if (!value.includes('\\n'))
+            return value;
+        return value.replace(/\\n/g, '\n');
+    }
+    catch {
+        return value;
+    }
+};
+const stripConflictMarkers = (text) => {
+    try {
+        const lines = text.replace(/\r\n/g, '\n').split('\n');
+        const out = [];
+        for (const line of lines) {
+            if (line.startsWith('<<<<<<<') || line.startsWith('=======') || line.startsWith('>>>>>>>')) {
+                continue;
+            }
+            out.push(line);
+        }
+        return out.join('\n');
+    }
+    catch {
+        return text;
+    }
+};
+export const normalizeApplyPatchText = (raw) => {
+    if (!raw)
+        return raw;
+    let text = raw.replace(/\r\n/g, '\n');
+    text = decodeEscapedNewlinesIfNeeded(text);
+    text = stripCodeFences(text);
+    text = text.trim();
+    if (!text)
+        return raw;
+    text = stripConflictMarkers(text);
+    text = normalizeBeginEndMarkers(text);
+    // Some models emit a GNU unified diff wrapped in apply_patch markers, e.g.:
+    //   *** Begin Patch ***
+    //   --- a/file
+    //   +++ b/file
+    //   @@ ...
+    //   *** End Patch ***
+    // Convert it to apply_patch format so the client tool can execute it.
+    if (text.startsWith('*** Begin Patch') &&
+        !text.includes('*** Update File:') &&
+        !text.includes('*** Add File:') &&
+        !text.includes('*** Delete File:') &&
+        (/^---\s+/m.test(text) || /^\+\+\+\s+/m.test(text))) {
+        const lines = text.split('\n');
+        const inner = lines
+            .filter((l, idx) => {
+            if (idx === 0 && l.startsWith('*** Begin Patch'))
+                return false;
+            if (idx === lines.length - 1 && l.startsWith('*** End Patch'))
+                return false;
+            return true;
+        })
+            .join('\n')
+            .trim();
+        const converted = convertUnifiedDiffToApplyPatchIfPossible(inner);
+        if (converted) {
+            text = converted;
+        }
+    }
+    if (!text.includes('*** Begin Patch') && text.includes('diff --git')) {
+        const converted = convertGitDiffToApplyPatch(text);
+        if (converted)
+            text = converted;
+    }
+    else if (!text.includes('*** Begin Patch') &&
+        !text.includes('diff --git') &&
+        text.includes('***************') &&
+        /^\*\*\*\s+\S+/m.test(text) &&
+        /^---\s+\S+/m.test(text)) {
+        // Support classic "context diff" format:
+        //   *** path
+        //   --- path
+        //   ***************
+        //   *** 1,2 ****
+        //   --- 1,3 ----
+        const converted = convertContextDiffToApplyPatch(text);
+        if (converted)
+            text = converted;
+    }
+    else if (!text.includes('*** Begin Patch') && !text.includes('diff --git')) {
+        const converted = convertUnifiedDiffToApplyPatchIfPossible(text);
+        if (converted)
+            text = converted;
+    }
+    if (text.includes('*** Add File:')) {
+        text = text.replace(/\*\*\* Create File:/g, '*** Add File:');
+    }
+    let hasBegin = text.includes('*** Begin Patch');
+    const hasEnd = text.includes('*** End Patch');
+    if (hasBegin && !hasEnd) {
+        text = `${text}\n*** End Patch`;
+    }
+    if (!hasBegin && /^\*\*\* (Add|Update|Delete) File:/m.test(text)) {
+        text = `*** Begin Patch\n${text}\n*** End Patch`;
+        hasBegin = true;
+    }
+    if (!text.includes('*** Begin Patch')) {
+        return text;
+    }
+    const beginIndex = text.indexOf('*** Begin Patch');
+    if (beginIndex > 0) {
+        text = text.slice(beginIndex);
+    }
+    const endMarker = '*** End Patch';
+    const firstEndIndex = text.indexOf(endMarker);
+    const concatSignatures = [
+        `${endMarker}","input":"*** Begin Patch`,
+        `${endMarker}","patch":"*** Begin Patch`,
+        `${endMarker}\\",\\"input\\":\\"*** Begin Patch`,
+        `${endMarker}\\",\\"patch\\":\\"*** Begin Patch`
+    ];
+    const hasConcatenationSignal = concatSignatures.some((sig) => text.includes(sig));
+    if (hasConcatenationSignal && firstEndIndex >= 0) {
+        text = text.slice(0, firstEndIndex + endMarker.length);
+    }
+    else {
+        const lastEndIndex = text.lastIndexOf(endMarker);
+        if (lastEndIndex >= 0) {
+            const afterEnd = text.slice(lastEndIndex + endMarker.length);
+            if (afterEnd.trim().length > 0) {
+                text = text.slice(0, lastEndIndex + endMarker.length);
+            }
+        }
+    }
+    // Fix missing prefix lines in Update File sections: treat as context (" ").
+    const lines = text.split('\n');
+    const output = [];
+    let inUpdateSection = false;
+    let afterUpdateHeader = false;
+    for (const line of lines) {
+        if (line.startsWith('*** Begin Patch')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** End Patch')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** Update File:')) {
+            output.push(line);
+            inUpdateSection = true;
+            afterUpdateHeader = true;
+            continue;
+        }
+        if (line.startsWith('*** Add File:') || line.startsWith('*** Delete File:')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (inUpdateSection) {
+            if (afterUpdateHeader && line.trim() === '') {
+                continue;
+            }
+            afterUpdateHeader = false;
+            if (line.startsWith('@@') || line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+                output.push(line);
+            }
+            else {
+                output.push(` ${line}`);
+            }
+            continue;
+        }
+        output.push(line);
+    }
+    return output.join('\n');
+};
+export { looksLikePatch };

package/dist/tools/apply-patch/structured/coercion.d.ts

@@ -0,0 +1,3 @@
+import type { StructuredApplyPatchPayload } from '../structured.js';
+import { type UnknownRecord } from '../validation/shared.js';
+export declare const coerceStructuredPayload: (record: UnknownRecord) => StructuredApplyPatchPayload | undefined;

package/dist/tools/apply-patch/structured/coercion.js

@@ -0,0 +1,82 @@
+import { isStructuredApplyPatchPayload } from '../structured.js';
+import { tryParseJson } from '../json/parse-loose.js';
+import { asString } from '../validation/shared.js';
+const buildSingleChangePayload = (record) => {
+    const kindRaw = asString(record.kind);
+    if (!kindRaw)
+        return undefined;
+    const change = {
+        kind: kindRaw.toLowerCase(),
+        lines: record.lines ?? record.text ?? record.body,
+        target: asString(record.target) ?? undefined,
+        anchor: asString(record.anchor) ?? undefined
+    };
+    if (typeof record.use_anchor_indent === 'boolean') {
+        change.use_anchor_indent = record.use_anchor_indent;
+    }
+    const changeFile = asString(record.file);
+    if (changeFile) {
+        change.file = changeFile;
+    }
+    return { file: changeFile, changes: [change] };
+};
+const coerceChangesArray = (value) => {
+    const parsed = tryParseJson(value);
+    if (!parsed)
+        return undefined;
+    if (Array.isArray(parsed)) {
+        const items = parsed.filter((entry) => entry && typeof entry === 'object');
+        if (!items.length)
+            return undefined;
+        // Ensure at least one entry looks like a structured change.
+        if (!items.some((c) => typeof c.kind === 'string' && String(c.kind).trim()))
+            return undefined;
+        return items;
+    }
+    if (parsed && typeof parsed === 'object' && Array.isArray(parsed.changes)) {
+        const items = parsed.changes.filter((entry) => entry && typeof entry === 'object');
+        if (!items.length)
+            return undefined;
+        if (!items.some((c) => typeof c.kind === 'string' && String(c.kind).trim()))
+            return undefined;
+        return items;
+    }
+    return undefined;
+};
+export const coerceStructuredPayload = (record) => {
+    if (isStructuredApplyPatchPayload(record)) {
+        return record;
+    }
+    if (Array.isArray(record.changes) && record.changes.length === 0) {
+        return undefined;
+    }
+    // Common shape error: { file, instructions: "[{...},{...}]" } where instructions contains JSON changes.
+    if (!Array.isArray(record.changes)) {
+        const changesFromInstructions = coerceChangesArray(record.instructions);
+        if (changesFromInstructions) {
+            return {
+                ...(typeof record.file === 'string' ? { file: record.file } : {}),
+                changes: changesFromInstructions
+            };
+        }
+        // Another common shape: changes is a JSON string.
+        const changesFromString = coerceChangesArray(record.changes);
+        if (changesFromString) {
+            return {
+                ...(typeof record.file === 'string' ? { file: record.file } : {}),
+                changes: changesFromString
+            };
+        }
+        const editsFromString = coerceChangesArray(record.edits ?? record.operations ?? record.ops);
+        if (editsFromString) {
+            return {
+                ...(typeof record.file === 'string' ? { file: record.file } : {}),
+                changes: editsFromString
+            };
+        }
+    }
+    const single = buildSingleChangePayload(record);
+    if (single)
+        return single;
+    return undefined;
+};

package/dist/tools/apply-patch/validation/shared.d.ts

@@ -0,0 +1,3 @@
+export type UnknownRecord = Record<string, unknown>;
+export declare const isRecord: (value: unknown) => value is UnknownRecord;
+export declare const asString: (value: unknown) => string | null;