@jsonstudio/llms 0.6.473 → 0.6.567

package/dist/tools/tool-registry.js

@@ -43,6 +43,164 @@ const toJson = (value) => {
         return '{}';
     }
 };
+const APPLY_PATCH_SECTION_RE = /^\*\*\*\s+(Add|Update|Delete|Copy|Move)\s+File:\s*(.+)$/;
+const sanitizeRelativePath = (value) => {
+    if (!value)
+        return null;
+    const trimmed = value.trim().replace(/\\/g, '/');
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith('/'))
+        return null;
+    if (/^[a-zA-Z]:/.test(trimmed))
+        return null;
+    if (trimmed.includes('\0'))
+        return null;
+    if (trimmed.includes('..')) {
+        const segments = trimmed.split('/');
+        if (segments.some((seg) => seg === '..')) {
+            return null;
+        }
+    }
+    return trimmed.replace(/\/{2,}/g, '/');
+};
+const collectExplicitPaths = (record) => {
+    const bucket = [];
+    const invalid = [];
+    const pushPath = (candidate) => {
+        const str = asString(candidate);
+        const normalized = sanitizeRelativePath(str);
+        if (normalized)
+            bucket.push(normalized);
+        else if (typeof candidate === 'string')
+            invalid.push(candidate);
+    };
+    const entries = [
+        record.paths,
+        record.path,
+        record.files,
+        record.file,
+        record.targets,
+        record.target_path
+    ];
+    for (const entry of entries) {
+        if (!entry)
+            continue;
+        if (typeof entry === 'string') {
+            pushPath(entry);
+        }
+        else if (Array.isArray(entry)) {
+            entry.forEach((item) => {
+                if (typeof item === 'string')
+                    pushPath(item);
+                else if (isRecord(item))
+                    pushPath(item.path);
+            });
+        }
+        else if (isRecord(entry)) {
+            pushPath(entry.path ?? entry.value);
+        }
+    }
+    return { paths: bucket, invalid };
+};
+const looksLikePatchBody = (text) => {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return false;
+    const hunkRe = /^@@/m;
+    const diffLineRe = /^[ +-]/m;
+    return hunkRe.test(trimmed) || diffLineRe.test(trimmed);
+};
+const applyPathOverrides = (lines, overridePaths) => {
+    if (!overridePaths.length)
+        return;
+    const sections = [];
+    for (let i = 0; i < lines.length; i += 1) {
+        const match = lines[i].match(APPLY_PATCH_SECTION_RE);
+        if (match) {
+            sections.push({ index: i, action: match[1] });
+        }
+    }
+    if (!sections.length) {
+        const beginIdx = lines.findIndex((line) => line.trim() === '*** Begin Patch');
+        if (beginIdx >= 0) {
+            lines.splice(beginIdx + 1, 0, `*** Update File: ${overridePaths[0]}`);
+        }
+        return;
+    }
+    const limit = Math.min(sections.length, overridePaths.length);
+    for (let i = 0; i < limit; i += 1) {
+        lines[sections[i].index] = `*** ${sections[i].action} File: ${overridePaths[i]}`;
+    }
+};
+const normalizeApplyPatchInput = (rawPatch, options) => {
+    if (typeof rawPatch !== 'string') {
+        return null;
+    }
+    const text = rawPatch.replace(/\r\n/g, '\n');
+    const beginIdx = text.toLowerCase().indexOf('*** begin patch');
+    const endIdx = text.toLowerCase().lastIndexOf('*** end patch');
+    let candidate = '';
+    if (beginIdx >= 0 && endIdx >= 0 && endIdx > beginIdx) {
+        candidate = text.slice(beginIdx, endIdx + '*** End Patch'.length);
+    }
+    else if (options?.overridePaths && options.overridePaths.length) {
+        if (!looksLikePatchBody(text)) {
+            return null;
+        }
+        const headerPath = options.overridePaths[0];
+        candidate = ['*** Begin Patch', `*** Update File: ${headerPath}`, text.trim(), '*** End Patch'].join('\n');
+    }
+    else {
+        return null;
+    }
+    const lines = candidate.split(/\r?\n/);
+    if (!lines.length) {
+        return null;
+    }
+    let firstIdx = 0;
+    while (firstIdx < lines.length && lines[firstIdx].trim().length === 0) {
+        firstIdx += 1;
+    }
+    if (firstIdx >= lines.length) {
+        return null;
+    }
+    const firstLineRaw = lines[firstIdx];
+    const firstLineTrimmed = firstLineRaw.trim();
+    if (!firstLineTrimmed.toLowerCase().startsWith('*** begin patch')) {
+        return null;
+    }
+    if (firstLineTrimmed !== '*** Begin Patch') {
+        lines[firstIdx] = '*** Begin Patch';
+    }
+    let lastIdx = lines.length - 1;
+    while (lastIdx > firstIdx && lines[lastIdx].trim().length === 0) {
+        lastIdx -= 1;
+    }
+    if (lastIdx > firstIdx) {
+        const lastLineTrimmed = lines[lastIdx].trim();
+        if (lastLineTrimmed.toLowerCase().startsWith('*** end patch') && lastLineTrimmed !== '*** End Patch') {
+            lines[lastIdx] = '*** End Patch';
+        }
+    }
+    if (options?.overridePaths && options.overridePaths.length) {
+        applyPathOverrides(lines, options.overridePaths);
+    }
+    const normalized = lines.join('\n');
+    if (!normalized.includes('*** Begin Patch') || !normalized.includes('*** End Patch')) {
+        return null;
+    }
+    return normalized;
+};
+const logApplyPatchValidatorError = (message) => {
+    try {
+        // eslint-disable-next-line no-console
+        console.error(`\x1b[31m[apply_patch][validator] ${message}\x1b[0m`);
+    }
+    catch {
+        /* ignore */
+    }
+};
 const detectForbiddenWrite = (script) => {
     const normalized = script.toLowerCase();
     if (!normalized) {
@@ -95,12 +253,45 @@ export function validateToolCall(name, argsString) {
     const rawArgs = tryParseJson(typeof argsString === 'string' ? argsString : '{}');
     switch (normalizedName) {
         case 'apply_patch': {
-            const input = asString(rawArgs.input);
-            const patch = asString(rawArgs.patch) ?? input;
-            if (!patch) {
+            const record = rawArgs;
+            const inputField = asString(record.input);
+            const patchField = asString(record.patch);
+            const rawStr = typeof argsString === 'string' ? argsString : '';
+            let patchRaw = null;
+            if (patchField) {
+                patchRaw = patchField;
+            }
+            else if (inputField) {
+                patchRaw = inputField;
+            }
+            else if (rawStr && /\*\*\*\s+Begin Patch/i.test(rawStr)) {
+                patchRaw = rawStr;
+            }
+            if (!patchRaw) {
+                logApplyPatchValidatorError('missing apply_patch patch/input payload');
                 return { ok: false, reason: 'missing_input' };
             }
-            return { ok: true, normalizedArgs: toJson({ input: patch, patch }) };
+            const { paths: explicitPaths, invalid } = collectExplicitPaths(record);
+            if (invalid.length) {
+                invalid.forEach((value) => logApplyPatchValidatorError(`invalid path argument: ${value}`));
+            }
+            const normalizedPatch = normalizeApplyPatchInput(patchRaw, { overridePaths: explicitPaths });
+            if (!normalizedPatch) {
+                logApplyPatchValidatorError('patch text missing *** Begin Patch/*** End Patch or failed to auto-wrap with provided paths');
+                return { ok: false, reason: 'invalid_patch_header' };
+            }
+            // Canonical, parameterized shape; keep input for backwards compatibility.
+            const payload = {
+                patch: normalizedPatch,
+                input: normalizedPatch
+            };
+            if (explicitPaths.length) {
+                payload.paths = explicitPaths;
+            }
+            return {
+                ok: true,
+                normalizedArgs: toJson(payload)
+            };
         }
         case 'shell': {
             const rawCommand = rawArgs.command;

package/package.json

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