@jsonstudio/llms 0.6.753 → 0.6.802

package/dist/tools/apply-patch/validator.js

@@ -0,0 +1,616 @@
+import { buildStructuredPatch, isStructuredApplyPatchPayload, StructuredApplyPatchError } from './structured.js';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const asString = (value) => {
+    if (typeof value === 'string' && value.trim().length > 0)
+        return value;
+    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;
+};
+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));
+};
+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;
+    }
+};
+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;
+        }
+        if (current.path && current.lines.length) {
+            files.push(current);
+        }
+        current = null;
+    };
+    const extractPath = (value) => {
+        const v = String(value || '').trim();
+        if (!v)
+            return '';
+        const m = v.match(/^(?:a\/|b\/)?(.+)$/);
+        return (m && m[1] ? m[1] : v).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: [] };
+            continue;
+        }
+        if (!current)
+            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('--- ') || line.startsWith('+++ ') || line.startsWith('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;
+    const out = ['*** Begin Patch'];
+    for (const file of files) {
+        if (file.kind === 'delete') {
+            out.push(`*** Delete File: ${file.path}`);
+            continue;
+        }
+        if (file.kind === 'add') {
+            out.push(`*** Add File: ${file.path}`);
+            for (const l of file.lines) {
+                if (l.startsWith('+'))
+                    out.push(l);
+            }
+            continue;
+        }
+        out.push(`*** Update File: ${file.path}`);
+        out.push(...file.lines);
+    }
+    out.push('*** End Patch');
+    return out.join('\n');
+};
+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);
+    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')) {
+        const minusMatch = text.match(/^---\s+(.*)$/m);
+        const plusMatch = text.match(/^\+\+\+\s+(.*)$/m);
+        if (minusMatch && plusMatch) {
+            const rawPlus = plusMatch[1] || '';
+            const pathMatch = rawPlus.match(/^(?:b\/)?(.+)$/);
+            const filePath = (pathMatch && pathMatch[1] ? pathMatch[1] : rawPlus).trim();
+            if (filePath) {
+                const synthetic = `diff --git a/${filePath} b/${filePath}\n${text}`;
+                const converted = convertGitDiffToApplyPatch(synthetic);
+                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');
+};
+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 tryParseJson = (value) => {
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
+        return undefined;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+};
+const escapeUnescapedQuotesInJsonStrings = (input) => {
+    // Best-effort: when JSON is almost valid but contains unescaped `"` inside string values
+    // (e.g. JSX snippets like className="..."), escape quotes that are not followed by a
+    // valid JSON token delimiter. Deterministic; does not attempt to fix structural issues.
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] ?? '';
+        if (!inString) {
+            if (ch === '"') {
+                inString = true;
+                escaped = false;
+            }
+            out += ch;
+            continue;
+        }
+        if (escaped) {
+            out += ch;
+            escaped = false;
+            continue;
+        }
+        if (ch === '\\') {
+            out += ch;
+            escaped = true;
+            continue;
+        }
+        if (ch === '"') {
+            let j = i + 1;
+            while (j < input.length && /\s/.test(input[j] ?? ''))
+                j += 1;
+            const next = j < input.length ? input[j] : '';
+            if (next === '' || next === ':' || next === ',' || next === '}' || next === ']') {
+                inString = false;
+                out += ch;
+            }
+            else {
+                out += '\\"';
+            }
+            continue;
+        }
+        out += ch;
+    }
+    return out;
+};
+const balanceJsonContainers = (input) => {
+    // Best-effort bracket/brace balancing for JSON-like strings.
+    // Only operates outside string literals. When encountering a closing token that doesn't
+    // match the current stack top, inserts the missing closer(s) to recover.
+    let out = '';
+    let inString = false;
+    let escaped = false;
+    const stack = [];
+    const closeFor = (open) => (open === '{' ? '}' : ']');
+    for (let i = 0; i < input.length; i += 1) {
+        const ch = input[i] ?? '';
+        if (inString) {
+            out += ch;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (ch === '\\') {
+                escaped = true;
+                continue;
+            }
+            if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+            out += ch;
+            continue;
+        }
+        if (ch === '{' || ch === '[') {
+            stack.push(ch);
+            out += ch;
+            continue;
+        }
+        if (ch === '}' || ch === ']') {
+            const expectedOpen = ch === '}' ? '{' : '[';
+            while (stack.length && stack[stack.length - 1] !== expectedOpen) {
+                const open = stack.pop();
+                out += closeFor(open);
+            }
+            if (stack.length && stack[stack.length - 1] === expectedOpen) {
+                stack.pop();
+            }
+            out += ch;
+            continue;
+        }
+        out += ch;
+    }
+    while (stack.length) {
+        const open = stack.pop();
+        out += closeFor(open);
+    }
+    return out;
+};
+const tryParseJsonLoose = (value) => {
+    const parsed = tryParseJson(value);
+    if (parsed !== undefined)
+        return parsed;
+    if (typeof value !== 'string')
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
+        return undefined;
+    let repaired = escapeUnescapedQuotesInJsonStrings(trimmed);
+    repaired = balanceJsonContainers(repaired);
+    if (!repaired || repaired === trimmed)
+        return undefined;
+    try {
+        return JSON.parse(repaired);
+    }
+    catch {
+        return undefined;
+    }
+};
+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;
+};
+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;
+};
+const toJson = (value) => {
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return '{}';
+    }
+};
+export function validateApplyPatchArgs(argsString, rawArgs) {
+    const rawTrimmed = typeof argsString === 'string' ? argsString.trim() : '';
+    const looksJsonContainer = rawTrimmed.startsWith('{') || rawTrimmed.startsWith('[');
+    // Raw patch text without JSON wrapper
+    if (!looksJsonContainer && looksLikePatch(rawTrimmed)) {
+        const patchText = normalizeApplyPatchText(rawTrimmed);
+        return { ok: true, normalizedArgs: toJson({ patch: patchText, input: patchText }) };
+    }
+    const extractFromRecord = (rec) => {
+        // Special case: argsString claims to be JSON but isn't parseable and raw text looks like a patch.
+        if (looksJsonContainer && Object.keys(rec).length === 0 && looksLikePatch(rawTrimmed)) {
+            return { patchText: normalizeApplyPatchText(rawTrimmed) };
+        }
+        const patchField = asString(rec.patch);
+        if (patchField && looksLikePatch(patchField)) {
+            return { patchText: normalizeApplyPatchText(patchField) };
+        }
+        const diffField = asString(rec.diff) ?? asString(rec.patchText) ?? asString(rec.body);
+        if (diffField && looksLikePatch(diffField)) {
+            return { patchText: normalizeApplyPatchText(diffField) };
+        }
+        const inputField = asString(rec.input);
+        if (inputField && looksLikePatch(inputField)) {
+            return { patchText: normalizeApplyPatchText(inputField) };
+        }
+        // Common shape: patch text stored under `instructions` (e.g. "*** Update File: ...").
+        const instructionsField = asString(rec.instructions);
+        if (instructionsField && looksLikePatch(instructionsField)) {
+            return { patchText: normalizeApplyPatchText(instructionsField) };
+        }
+        // Common wrapper shape (seen in codex samples): { _raw: "{...json...}" }.
+        // `_raw` may contain either patch text or a JSON-encoded structured payload.
+        const rawEnvelope = asString(rec._raw);
+        if (rawEnvelope) {
+            const trimmed = rawEnvelope.trim();
+            if (looksLikePatch(trimmed)) {
+                return { patchText: normalizeApplyPatchText(trimmed) };
+            }
+            const parsed = tryParseJsonLoose(trimmed);
+            if (parsed && isRecord(parsed)) {
+                return extractFromRecord(parsed);
+            }
+            if (Array.isArray(parsed) && parsed.length > 0) {
+                const changesArray = parsed.filter((entry) => isRecord(entry));
+                if (changesArray.length && changesArray.some((c) => typeof c.kind === 'string')) {
+                    const payload = { changes: changesArray };
+                    try {
+                        return { patchText: buildStructuredPatch(payload) };
+                    }
+                    catch (error) {
+                        if (!(error instanceof StructuredApplyPatchError))
+                            throw error;
+                        return { failureReason: error.reason || 'structured_apply_patch_error' };
+                    }
+                }
+            }
+        }
+        const payload = coerceStructuredPayload(rec);
+        if (payload) {
+            try {
+                return { patchText: buildStructuredPatch(payload) };
+            }
+            catch (error) {
+                if (!(error instanceof StructuredApplyPatchError))
+                    throw error;
+                return { failureReason: error.reason || 'structured_apply_patch_error' };
+            }
+        }
+        return {};
+    };
+    let patchText;
+    let failureReason;
+    if (isRecord(rawArgs)) {
+        const res = extractFromRecord(rawArgs);
+        patchText = res.patchText;
+        failureReason = res.failureReason;
+    }
+    else if (Array.isArray(rawArgs) && rawArgs.length > 0) {
+        // compatibility: arguments may be either:
+        // - a single-element array [{ file, changes: [...] }]
+        // - a raw changes array [{ kind, ... }, ...]
+        const first = rawArgs.find((entry) => isRecord(entry));
+        if (first && Array.isArray(first.changes)) {
+            const res = extractFromRecord(first);
+            patchText = res.patchText;
+            failureReason = res.failureReason;
+        }
+        else {
+            const changesArray = rawArgs.filter((entry) => isRecord(entry));
+            if (changesArray.length && changesArray.some((c) => typeof c.kind === 'string')) {
+                const payload = { changes: changesArray };
+                try {
+                    patchText = buildStructuredPatch(payload);
+                }
+                catch (error) {
+                    if (!(error instanceof StructuredApplyPatchError))
+                        throw error;
+                    failureReason = error.reason || 'structured_apply_patch_error';
+                }
+            }
+        }
+    }
+    else if (typeof rawArgs === 'string' && looksLikePatch(rawArgs)) {
+        patchText = normalizeApplyPatchText(rawArgs);
+    }
+    if (!patchText) {
+        if (failureReason)
+            return { ok: false, reason: failureReason };
+        if (looksJsonContainer &&
+            isRecord(rawArgs) &&
+            Object.keys(rawArgs).length === 0 &&
+            rawTrimmed.length > 0 &&
+            !looksLikePatch(rawTrimmed)) {
+            return { ok: false, reason: 'invalid_json' };
+        }
+        return { ok: false, reason: 'missing_changes' };
+    }
+    return { ok: true, normalizedArgs: toJson({ patch: patchText, input: patchText }) };
+}

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

@@ -1,20 +1 @@
-export type StructuredApplyPatchKind = 'insert_after' | 'insert_before' | 'replace' | 'delete' | 'create_file' | 'delete_file';
-export interface StructuredApplyPatchChange {
-    file?: string;
-    kind: StructuredApplyPatchKind | string;
-    anchor?: string;
-    target?: string;
-    lines?: string[] | string;
-    use_anchor_indent?: boolean;
-}
-export interface StructuredApplyPatchPayload extends Record<string, unknown> {
-    instructions?: string;
-    file?: string;
-    changes: StructuredApplyPatchChange[];
-}
-export declare class StructuredApplyPatchError extends Error {
-    reason: string;
-    constructor(reason: string, message: string);
-}
-export declare function buildStructuredPatch(payload: StructuredApplyPatchPayload): string;
-export declare function isStructuredApplyPatchPayload(candidate: unknown): candidate is StructuredApplyPatchPayload;
+export * from './apply-patch/structured.js';