@jsonstudio/llms 0.6.567 → 0.6.568

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

@@ -0,0 +1,239 @@
+export class StructuredApplyPatchError extends Error {
+    reason;
+    constructor(reason, message) {
+        super(message);
+        this.reason = reason;
+    }
+}
+const SUPPORTED_KINDS = [
+    'insert_after',
+    'insert_before',
+    'replace',
+    'delete',
+    'create_file',
+    'delete_file'
+];
+const FILE_PATH_INVALID_RE = /[\r\n]/;
+const INVALID_FILE_FORMAT_RE = /^([A-Za-z]:|\/)/;
+const toSafeString = (value, label) => {
+    const str = typeof value === 'string' ? value : '';
+    if (!str.trim()) {
+        throw new StructuredApplyPatchError('missing_field', `${label} is required`);
+    }
+    return str;
+};
+const normalizeFilePath = (raw, label) => {
+    const trimmed = raw.trim();
+    if (!trimmed) {
+        throw new StructuredApplyPatchError('invalid_file', `${label} must not be empty`);
+    }
+    if (FILE_PATH_INVALID_RE.test(trimmed)) {
+        throw new StructuredApplyPatchError('invalid_file', `${label} must be a single-line relative path`);
+    }
+    if (INVALID_FILE_FORMAT_RE.test(trimmed)) {
+        throw new StructuredApplyPatchError('invalid_file', `${label} must be relative to the workspace root`);
+    }
+    return trimmed.replace(/\\/g, '/');
+};
+const splitTextIntoLines = (input) => {
+    const normalized = input.replace(/\r/g, '');
+    const parts = normalized.split('\n');
+    if (parts.length && parts[parts.length - 1] === '') {
+        parts.pop();
+    }
+    return parts.length ? parts : [''];
+};
+const normalizeLines = (value, label) => {
+    if (Array.isArray(value)) {
+        if (!value.length) {
+            return [];
+        }
+        return value.map((entry, idx) => {
+            if (typeof entry !== 'string') {
+                if (entry === null || entry === undefined) {
+                    return '';
+                }
+                return String(entry);
+            }
+            // Preserve intentional whitespace
+            return entry.replace(/\r/g, '');
+        });
+    }
+    if (typeof value === 'string') {
+        return splitTextIntoLines(value);
+    }
+    if (value === null || value === undefined) {
+        throw new StructuredApplyPatchError('invalid_lines', `${label} must be an array of strings or a multi-line string`);
+    }
+    return [String(value)];
+};
+const buildContextLines = (raw) => splitTextIntoLines(raw).map((line) => ` ${line}`);
+const buildPrefixedLines = (lines, prefix) => lines.map((line) => `${prefix}${line}`);
+const detectIndentFromAnchor = (anchorLines, mode) => {
+    const source = mode === 'first' ? anchorLines[0] ?? '' : anchorLines[anchorLines.length - 1] ?? '';
+    const match = source.match(/^(\s*)/);
+    return match ? match[1] ?? '' : '';
+};
+const applyAnchorIndent = (lines, anchorLines, position, enabled) => {
+    if (!enabled) {
+        return lines;
+    }
+    const indent = detectIndentFromAnchor(anchorLines, position);
+    if (!indent) {
+        return lines;
+    }
+    return lines.map((line) => {
+        if (!line.trim()) {
+            return line;
+        }
+        if (/^\s/.test(line)) {
+            return line;
+        }
+        return `${indent}${line}`;
+    });
+};
+export function buildStructuredPatch(payload) {
+    if (!payload || typeof payload !== 'object') {
+        throw new StructuredApplyPatchError('missing_payload', 'apply_patch arguments must be a JSON object');
+    }
+    if (!Array.isArray(payload.changes) || payload.changes.length === 0) {
+        throw new StructuredApplyPatchError('missing_changes', 'apply_patch requires a non-empty "changes" array');
+    }
+    const topLevelFile = typeof payload.file === 'string' && payload.file.trim()
+        ? normalizeFilePath(payload.file, 'file')
+        : undefined;
+    const sectionOrder = [];
+    const fileSections = new Map();
+    const ensureUpdateSection = (file) => {
+        const existing = fileSections.get(file);
+        if (existing) {
+            if (existing.type !== 'update') {
+                throw new StructuredApplyPatchError('invalid_change_sequence', `File "${file}" already marked as ${existing.type}`);
+            }
+            return existing;
+        }
+        const created = { type: 'update', hunks: [] };
+        sectionOrder.push(file);
+        fileSections.set(file, created);
+        return created;
+    };
+    for (const [index, change] of payload.changes.entries()) {
+        if (!change || typeof change !== 'object') {
+            throw new StructuredApplyPatchError('invalid_change', `Change at index ${index} must be an object`);
+        }
+        const kindRaw = typeof change.kind === 'string' ? change.kind.trim().toLowerCase() : '';
+        if (!kindRaw) {
+            throw new StructuredApplyPatchError('invalid_change_kind', `Change at index ${index} is missing "kind"`);
+        }
+        if (!SUPPORTED_KINDS.includes(kindRaw)) {
+            throw new StructuredApplyPatchError('invalid_change_kind', `Unsupported change kind "${change.kind}" at index ${index}`);
+        }
+        const file = change.file ? normalizeFilePath(change.file, `changes[${index}].file`) : topLevelFile;
+        if (!file) {
+            throw new StructuredApplyPatchError('invalid_file', `Change at index ${index} is missing "file"`);
+        }
+        if (kindRaw === 'create_file') {
+            if (fileSections.has(file)) {
+                throw new StructuredApplyPatchError('invalid_change_sequence', `File "${file}" already has pending changes`);
+            }
+            const lines = normalizeLines(change.lines, `changes[${index}].lines`);
+            sectionOrder.push(file);
+            fileSections.set(file, { type: 'add', lines });
+            continue;
+        }
+        if (kindRaw === 'delete_file') {
+            if (fileSections.has(file)) {
+                throw new StructuredApplyPatchError('invalid_change_sequence', `File "${file}" already has pending changes`);
+            }
+            sectionOrder.push(file);
+            fileSections.set(file, { type: 'delete' });
+            continue;
+        }
+        const section = ensureUpdateSection(file);
+        switch (kindRaw) {
+            case 'insert_after': {
+                const anchor = toSafeString(change.anchor, `changes[${index}].anchor`);
+                const anchorLines = splitTextIntoLines(anchor);
+                const additions = normalizeLines(change.lines, `changes[${index}].lines`);
+                if (!additions.length) {
+                    throw new StructuredApplyPatchError('invalid_lines', `changes[${index}].lines must include at least one line`);
+                }
+                const prepared = applyAnchorIndent(additions, anchorLines, 'last', change.use_anchor_indent);
+                const hunkBody = [...buildContextLines(anchor), ...buildPrefixedLines(prepared, '+')];
+                section.hunks.push(hunkBody);
+                break;
+            }
+            case 'insert_before': {
+                const anchor = toSafeString(change.anchor, `changes[${index}].anchor`);
+                const anchorLines = splitTextIntoLines(anchor);
+                const additions = normalizeLines(change.lines, `changes[${index}].lines`);
+                if (!additions.length) {
+                    throw new StructuredApplyPatchError('invalid_lines', `changes[${index}].lines must include at least one line`);
+                }
+                const prepared = applyAnchorIndent(additions, anchorLines, 'first', change.use_anchor_indent);
+                const hunkBody = [...buildPrefixedLines(prepared, '+'), ...buildContextLines(anchor)];
+                section.hunks.push(hunkBody);
+                break;
+            }
+            case 'replace': {
+                const target = toSafeString(change.target, `changes[${index}].target`);
+                const replacements = normalizeLines(change.lines, `changes[${index}].lines`);
+                const hunkBody = [
+                    ...buildPrefixedLines(splitTextIntoLines(target), '-'),
+                    ...buildPrefixedLines(replacements, '+')
+                ];
+                section.hunks.push(hunkBody);
+                break;
+            }
+            case 'delete': {
+                const target = toSafeString(change.target, `changes[${index}].target`);
+                const hunkBody = buildPrefixedLines(splitTextIntoLines(target), '-');
+                section.hunks.push(hunkBody);
+                break;
+            }
+            default: {
+                throw new StructuredApplyPatchError('invalid_change_kind', `Unsupported change kind "${change.kind}" at index ${index}`);
+            }
+        }
+    }
+    if (!sectionOrder.length) {
+        throw new StructuredApplyPatchError('missing_changes', 'apply_patch payload produced no file operations');
+    }
+    const lines = ['*** Begin Patch'];
+    for (const file of sectionOrder) {
+        const section = fileSections.get(file);
+        if (!section)
+            continue;
+        if (section.type === 'add') {
+            lines.push(`*** Add File: ${file}`);
+            for (const line of section.lines) {
+                lines.push(`+${line}`);
+            }
+        }
+        else if (section.type === 'delete') {
+            lines.push(`*** Delete File: ${file}`);
+        }
+        else {
+            lines.push(`*** Update File: ${file}`);
+            for (const hunk of section.hunks) {
+                lines.push('@@');
+                for (const entry of hunk) {
+                    lines.push(entry);
+                }
+                lines.push('@@');
+            }
+        }
+    }
+    lines.push('*** End Patch');
+    return lines.join('\n');
+}
+export function isStructuredApplyPatchPayload(candidate) {
+    if (!candidate || typeof candidate !== 'object') {
+        return false;
+    }
+    const record = candidate;
+    if (!Array.isArray(record.changes)) {
+        return false;
+    }
+    return true;
+}

package/dist/tools/tool-description-utils.d.ts

@@ -0,0 +1,5 @@
+export declare function normalizeToolName(value: unknown): string;
+export declare function isShellToolName(value: unknown): boolean;
+export declare function hasApplyPatchToolDeclared(tools: unknown[] | undefined): boolean;
+export declare function buildShellDescription(toolDisplayName: string, hasApplyPatch: boolean): string;
+export declare function appendApplyPatchReminder(description: string, hasApplyPatch: boolean): string;

package/dist/tools/tool-description-utils.js

@@ -0,0 +1,50 @@
+const SHELL_TOOL_ALIASES = new Set(['shell', 'shell_command', 'exec_command']);
+const APPLY_PATCH_NAME = 'apply_patch';
+export function normalizeToolName(value) {
+    return typeof value === 'string' ? value.trim().toLowerCase() : '';
+}
+function extractToolFunctionName(entry) {
+    if (!entry || typeof entry !== 'object') {
+        return '';
+    }
+    const fnName = typeof entry.function?.name === 'string'
+        ? entry.function.name
+        : undefined;
+    if (fnName && fnName.trim().length > 0) {
+        return fnName.trim();
+    }
+    const topName = typeof entry.name === 'string' ? entry.name : '';
+    return topName.trim();
+}
+export function isShellToolName(value) {
+    return SHELL_TOOL_ALIASES.has(normalizeToolName(value));
+}
+export function hasApplyPatchToolDeclared(tools) {
+    if (!Array.isArray(tools)) {
+        return false;
+    }
+    return tools.some((entry) => normalizeToolName(extractToolFunctionName(entry)) === APPLY_PATCH_NAME);
+}
+export function buildShellDescription(toolDisplayName, hasApplyPatch) {
+    const label = toolDisplayName && toolDisplayName.trim().length > 0
+        ? toolDisplayName.trim()
+        : 'shell';
+    const base = 'Runs a shell command and returns its output.';
+    const workdirLine = `- Always set the \`workdir\` param when using the ${label} function. Avoid using \`cd\` unless absolutely necessary.`;
+    const applyPatchLine = '- Prefer apply_patch for editing files instead of shell redirection or here-doc usage.';
+    return hasApplyPatch ? `${base}\n${workdirLine}\n${applyPatchLine}` : `${base}\n${workdirLine}`;
+}
+export function appendApplyPatchReminder(description, hasApplyPatch) {
+    if (!hasApplyPatch) {
+        return description;
+    }
+    const trimmed = description?.trim() ?? '';
+    if (!trimmed) {
+        return buildShellDescription('shell', true);
+    }
+    if (trimmed.includes('apply_patch')) {
+        return trimmed;
+    }
+    const applyPatchLine = '- Prefer apply_patch for editing files instead of shell redirection or here-doc usage.';
+    return `${trimmed}\n${applyPatchLine}`;
+}

package/dist/tools/tool-registry.js

@@ -1,4 +1,5 @@
 // Tool registry and validator (single source of truth)
+import { buildStructuredPatch, isStructuredApplyPatchPayload, StructuredApplyPatchError } from './apply-patch-structured.js';
 const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
 const asString = (value) => {
     if (typeof value === 'string' && value.trim().length > 0) {
@@ -43,164 +44,6 @@ 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) {
@@ -254,44 +97,19 @@ export function validateToolCall(name, argsString) {
     switch (normalizedName) {
         case 'apply_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 (!isStructuredApplyPatchPayload(record)) {
+                return { ok: false, reason: 'missing_changes' };
             }
-            if (!patchRaw) {
-                logApplyPatchValidatorError('missing apply_patch patch/input payload');
-                return { ok: false, reason: 'missing_input' };
+            try {
+                const patchText = buildStructuredPatch(record);
+                return { ok: true, normalizedArgs: toJson({ patch: patchText, input: patchText }) };
             }
-            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;
+            catch (error) {
+                if (error instanceof StructuredApplyPatchError) {
+                    return { ok: false, reason: error.reason || 'invalid_patch_payload' };
+                }
+                return { ok: false, reason: 'invalid_patch_payload' };
             }
-            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.567",
+  "version": "0.6.568",
   "type": "module",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -62,4 +62,4 @@
     "dist",
     "README.md"
   ]
-}
+}