@jsonstudio/llms 0.6.1643 → 0.6.1739

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

@@ -1,8 +1,5 @@
-import { buildStructuredPatch, StructuredApplyPatchError } from './structured.js';
-import { coerceStructuredPayload } from './structured/coercion.js';
-import { tryParseJsonLoose } from './json/parse-loose.js';
+import { normalizeApplyPatchArgs } from './args-normalizer/index.js';
 import { normalizeApplyPatchText, looksLikePatch } from './patch-text/normalize.js';
-import { asString, isRecord } from './validation/shared.js';
 export { looksLikePatch, normalizeApplyPatchText };
 const toJson = (value) => {
     try {
@@ -13,148 +10,12 @@ const toJson = (value) => {
     }
 };
 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);
-        if (!patchText.includes('*** Begin Patch')) {
-            return { ok: false, reason: 'unsupported_patch_format' };
-        }
-        return { ok: true, normalizedArgs: toJson({ patch: patchText, input: patchText }) };
+    const normalized = normalizeApplyPatchArgs(argsString, rawArgs);
+    if (normalized.ok === false) {
+        return { ok: false, reason: normalized.reason };
     }
-    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)) {
-            const patchText = normalizeApplyPatchText(rawTrimmed);
-            if (!patchText.includes('*** Begin Patch'))
-                return { failureReason: 'unsupported_patch_format' };
-            return { patchText };
-        }
-        const patchField = asString(rec.patch);
-        if (patchField && looksLikePatch(patchField)) {
-            const patchText = normalizeApplyPatchText(patchField);
-            if (!patchText.includes('*** Begin Patch'))
-                return { failureReason: 'unsupported_patch_format' };
-            return { patchText };
-        }
-        const diffField = asString(rec.diff) ?? asString(rec.patchText) ?? asString(rec.body);
-        if (diffField && looksLikePatch(diffField)) {
-            const patchText = normalizeApplyPatchText(diffField);
-            if (!patchText.includes('*** Begin Patch'))
-                return { failureReason: 'unsupported_patch_format' };
-            return { patchText };
-        }
-        const inputField = asString(rec.input);
-        if (inputField && looksLikePatch(inputField)) {
-            const patchText = normalizeApplyPatchText(inputField);
-            if (!patchText.includes('*** Begin Patch'))
-                return { failureReason: 'unsupported_patch_format' };
-            return { patchText };
-        }
-        // Common shape: patch text stored under `instructions` (e.g. "*** Update File: ...").
-        const instructionsField = asString(rec.instructions);
-        if (instructionsField && looksLikePatch(instructionsField)) {
-            const patchText = normalizeApplyPatchText(instructionsField);
-            if (!patchText.includes('*** Begin Patch'))
-                return { failureReason: 'unsupported_patch_format' };
-            return { patchText };
-        }
-        // 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)) {
-                const patchText = normalizeApplyPatchText(trimmed);
-                if (!patchText.includes('*** Begin Patch'))
-                    return { failureReason: 'unsupported_patch_format' };
-                return { patchText };
-            }
-            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 {};
+    return {
+        ok: true,
+        normalizedArgs: toJson({ patch: normalized.patchText, input: normalized.patchText })
     };
-    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)) {
-        const normalized = normalizeApplyPatchText(rawArgs);
-        if (normalized.includes('*** Begin Patch')) {
-            patchText = normalized;
-        }
-        else {
-            failureReason = 'unsupported_patch_format';
-        }
-    }
-    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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsonstudio/llms",
-  "version": "0.6.1643",
+  "version": "0.6.1739",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",