@jsonstudio/llms 0.6.1643 → 0.6.1739

package/dist/tools/apply-patch/args-normalizer/extract-patch.js

@@ -0,0 +1,15 @@
+import { normalizeApplyPatchText, looksLikePatch } from '../patch-text/normalize.js';
+export function extractNormalizedPatch(value) {
+    if (!value) {
+        return {};
+    }
+    const normalized = normalizeApplyPatchText(value);
+    const patchLike = looksLikePatch(value) || looksLikePatch(normalized) || normalized.includes('*** Begin Patch');
+    if (!patchLike) {
+        return {};
+    }
+    if (!normalized.includes('*** Begin Patch')) {
+        return { failureReason: 'unsupported_patch_format' };
+    }
+    return { patchText: normalized };
+}

package/dist/tools/apply-patch/args-normalizer/index.d.ts

@@ -0,0 +1,2 @@
+import type { ApplyPatchNormalizeOptions, ApplyPatchNormalizeResult } from './types.js';
+export declare function normalizeApplyPatchArgs(argsString: string, rawArgs: unknown, options?: ApplyPatchNormalizeOptions): ApplyPatchNormalizeResult;

package/dist/tools/apply-patch/args-normalizer/index.js

@@ -0,0 +1,164 @@
+import { coerceStructuredPayload } from '../structured/coercion.js';
+import { tryParseJsonLoose } from '../json/parse-loose.js';
+import { looksLikePatch } from '../patch-text/normalize.js';
+import { asString, isRecord } from '../validation/shared.js';
+import { DEFAULT_APPLY_PATCH_NORMALIZE_ACTIONS } from './default-actions.js';
+import { extractNormalizedPatch } from './extract-patch.js';
+import { buildPatchFromChangesArray, buildPatchFromStructuredPayload, extractConflictPatchAsStructuredReplace, resolvePathAlias } from './structured-builders.js';
+function getActionList(options) {
+    if (Array.isArray(options?.actions) && options?.actions.length > 0) {
+        return options.actions;
+    }
+    return DEFAULT_APPLY_PATCH_NORMALIZE_ACTIONS;
+}
+function runRecordActions(record, state, actions, runNested, isFinalPass) {
+    for (const action of actions) {
+        if (action.action === 'record_text_fields') {
+            for (const field of action.fields) {
+                const value = asString(record[field]);
+                const extracted = extractNormalizedPatch(value);
+                if (extracted.patchText || extracted.failureReason) {
+                    return extracted;
+                }
+            }
+            continue;
+        }
+        if (action.action === 'record_conflict_patch') {
+            const patchFieldValue = asString(record[action.patchField]);
+            const pathAlias = resolvePathAlias(record, action.fileFields);
+            const extracted = extractConflictPatchAsStructuredReplace(pathAlias, patchFieldValue ?? undefined);
+            if (extracted.patchText || extracted.failureReason) {
+                return extracted;
+            }
+            continue;
+        }
+        if (action.action === 'record_raw_envelope') {
+            const rawEnvelope = asString(record[action.field]);
+            if (!rawEnvelope) {
+                continue;
+            }
+            const fromEnvelope = extractNormalizedPatch(rawEnvelope.trim());
+            if (fromEnvelope.patchText || fromEnvelope.failureReason) {
+                return fromEnvelope;
+            }
+            if (action.parseJson === false) {
+                continue;
+            }
+            const maxDepth = typeof action.maxDepth === 'number' ? action.maxDepth : 2;
+            if (state.depth >= maxDepth) {
+                continue;
+            }
+            const parsed = tryParseJsonLoose(rawEnvelope.trim());
+            if (isRecord(parsed) || Array.isArray(parsed)) {
+                const nested = runNested(rawEnvelope.trim(), parsed, state.depth + 1);
+                if (nested.patchText || nested.failureReason) {
+                    return nested;
+                }
+            }
+            continue;
+        }
+        if (action.action === 'record_structured_payload') {
+            const payload = coerceStructuredPayload(record);
+            const extracted = buildPatchFromStructuredPayload(payload);
+            if (extracted.patchText || extracted.failureReason) {
+                return extracted;
+            }
+            continue;
+        }
+        if (action.action === 'invalid_json_guard' && isFinalPass) {
+            if (state.looksJsonContainer &&
+                isRecord(state.rawArgs) &&
+                Object.keys(state.rawArgs).length === 0 &&
+                state.rawTrimmed.length > 0 &&
+                !looksLikePatch(state.rawTrimmed)) {
+                return { failureReason: 'invalid_json' };
+            }
+        }
+    }
+    return {};
+}
+function runActions(state, actions, runNested, isFinalPass) {
+    for (const action of actions) {
+        if (action.action === 'raw_non_json_patch') {
+            if (!state.looksJsonContainer) {
+                const extracted = extractNormalizedPatch(state.rawTrimmed);
+                if (extracted.patchText || extracted.failureReason) {
+                    return extracted;
+                }
+            }
+            continue;
+        }
+        if (action.action === 'json_container_patch_fallback') {
+            if (state.looksJsonContainer && isRecord(state.rawArgs) && Object.keys(state.rawArgs).length === 0) {
+                const extracted = extractNormalizedPatch(state.rawTrimmed);
+                if (extracted.patchText || extracted.failureReason) {
+                    return extracted;
+                }
+            }
+            continue;
+        }
+        if (action.action === 'array_structured_payload') {
+            if (!Array.isArray(state.rawArgs) || state.rawArgs.length === 0) {
+                continue;
+            }
+            const firstRecord = state.rawArgs.find((entry) => isRecord(entry));
+            if (firstRecord && Array.isArray(firstRecord.changes)) {
+                const extracted = runRecordActions(firstRecord, state, actions, runNested, isFinalPass);
+                if (extracted.patchText || extracted.failureReason) {
+                    return extracted;
+                }
+                continue;
+            }
+            const changesArray = state.rawArgs.filter((entry) => isRecord(entry));
+            const extracted = buildPatchFromChangesArray(changesArray);
+            if (extracted.patchText || extracted.failureReason) {
+                return extracted;
+            }
+            continue;
+        }
+        if (action.action === 'raw_string_patch') {
+            if (typeof state.rawArgs === 'string') {
+                const extracted = extractNormalizedPatch(state.rawArgs);
+                if (extracted.patchText || extracted.failureReason) {
+                    return extracted;
+                }
+            }
+            continue;
+        }
+        if (isRecord(state.rawArgs)) {
+            const extracted = runRecordActions(state.rawArgs, state, [action], runNested, isFinalPass);
+            if (extracted.patchText || extracted.failureReason) {
+                return extracted;
+            }
+        }
+    }
+    return {};
+}
+function normalizeState(argsString, rawArgs, depth) {
+    const rawTrimmed = typeof argsString === 'string' ? argsString.trim() : '';
+    return {
+        argsString,
+        rawArgs,
+        rawTrimmed,
+        looksJsonContainer: rawTrimmed.startsWith('{') || rawTrimmed.startsWith('['),
+        depth
+    };
+}
+function resolveExtraction(argsString, rawArgs, actions, depth, isFinalPass) {
+    const state = normalizeState(argsString, rawArgs, depth);
+    const runNested = (nextArgsString, nextRawArgs, nextDepth) => {
+        return resolveExtraction(nextArgsString, nextRawArgs, actions, nextDepth, false);
+    };
+    return runActions(state, actions, runNested, isFinalPass);
+}
+export function normalizeApplyPatchArgs(argsString, rawArgs, options) {
+    const actions = getActionList(options);
+    const extracted = resolveExtraction(argsString, rawArgs, actions, 0, true);
+    if (extracted.patchText) {
+        return { ok: true, patchText: extracted.patchText };
+    }
+    if (extracted.failureReason) {
+        return { ok: false, reason: extracted.failureReason };
+    }
+    return { ok: false, reason: 'missing_changes' };
+}

package/dist/tools/apply-patch/args-normalizer/structured-builders.d.ts

@@ -0,0 +1,7 @@
+import { type StructuredApplyPatchPayload } from '../structured.js';
+import { type UnknownRecord } from '../validation/shared.js';
+import type { ApplyPatchExtraction } from './types.js';
+export declare function resolvePathAlias(record: UnknownRecord, fileFields: string[]): string | undefined;
+export declare function buildPatchFromChangesArray(changesArray: UnknownRecord[]): ApplyPatchExtraction;
+export declare function buildPatchFromStructuredPayload(payload: StructuredApplyPatchPayload | undefined): ApplyPatchExtraction;
+export declare function extractConflictPatchAsStructuredReplace(filePath: string | undefined, conflictText: string | undefined): ApplyPatchExtraction;

package/dist/tools/apply-patch/args-normalizer/structured-builders.js

@@ -0,0 +1,85 @@
+import { buildStructuredPatch, StructuredApplyPatchError } from '../structured.js';
+import { asString } from '../validation/shared.js';
+export function resolvePathAlias(record, fileFields) {
+    for (const field of fileFields) {
+        const value = asString(record[field]);
+        if (value) {
+            return value;
+        }
+    }
+    return undefined;
+}
+function safeBuildStructuredPatch(payload) {
+    try {
+        return { patchText: buildStructuredPatch(payload) };
+    }
+    catch (error) {
+        if (!(error instanceof StructuredApplyPatchError)) {
+            throw error;
+        }
+        return { failureReason: error.reason || 'structured_apply_patch_error' };
+    }
+}
+export function buildPatchFromChangesArray(changesArray) {
+    if (!changesArray.length || !changesArray.some((change) => typeof change.kind === 'string')) {
+        return {};
+    }
+    const payload = {
+        changes: changesArray
+    };
+    return safeBuildStructuredPatch(payload);
+}
+export function buildPatchFromStructuredPayload(payload) {
+    if (!payload) {
+        return {};
+    }
+    return safeBuildStructuredPatch(payload);
+}
+export function extractConflictPatchAsStructuredReplace(filePath, conflictText) {
+    const safeFilePath = typeof filePath === 'string' ? filePath.trim() : '';
+    const safeText = typeof conflictText === 'string' ? conflictText : '';
+    if (!safeFilePath || !safeText) {
+        return {};
+    }
+    const lines = safeText.replace(/\r\n/g, '\n').replace(/\r/g, '\n').split('\n');
+    let start = -1;
+    let middle = -1;
+    let end = -1;
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index] ?? '';
+        if (start < 0) {
+            if (line.startsWith('<<<<<<<')) {
+                start = index;
+            }
+            continue;
+        }
+        if (middle < 0) {
+            if (line.startsWith('=======')) {
+                middle = index;
+            }
+            continue;
+        }
+        if (line.startsWith('>>>>>>>')) {
+            end = index;
+            break;
+        }
+    }
+    if (start < 0 || middle <= start || end <= middle) {
+        return {};
+    }
+    const original = lines.slice(start + 1, middle).join('\n');
+    const updated = lines.slice(middle + 1, end).join('\n');
+    if (!original.trim() || !updated.trim()) {
+        return {};
+    }
+    return safeBuildStructuredPatch({
+        file: safeFilePath,
+        changes: [
+            {
+                kind: 'replace',
+                target: original,
+                lines: updated
+            }
+        ]
+    });
+}

package/dist/tools/apply-patch/args-normalizer/types.d.ts

@@ -0,0 +1,54 @@
+import type { UnknownRecord } from '../validation/shared.js';
+export type ApplyPatchExtraction = {
+    patchText?: string;
+    failureReason?: string;
+};
+export type ApplyPatchNormalizeResult = {
+    ok: true;
+    patchText: string;
+} | {
+    ok: false;
+    reason: string;
+};
+export type ApplyPatchNormalizeAction = {
+    action: 'raw_non_json_patch';
+} | {
+    action: 'json_container_patch_fallback';
+} | {
+    action: 'record_text_fields';
+    fields: string[];
+} | {
+    action: 'record_conflict_patch';
+    patchField: string;
+    fileFields: string[];
+} | {
+    action: 'record_raw_envelope';
+    field: string;
+    parseJson?: boolean;
+    maxDepth?: number;
+} | {
+    action: 'record_structured_payload';
+} | {
+    action: 'array_structured_payload';
+} | {
+    action: 'raw_string_patch';
+} | {
+    action: 'invalid_json_guard';
+};
+export type ApplyPatchNormalizeOptions = {
+    actions?: ApplyPatchNormalizeAction[];
+};
+export type ApplyPatchNormalizeState = {
+    argsString: string;
+    rawArgs: unknown;
+    rawTrimmed: string;
+    looksJsonContainer: boolean;
+    depth: number;
+};
+export type ApplyPatchActionContext = {
+    state: ApplyPatchNormalizeState;
+    runNested: (argsString: string, rawArgs: unknown, depth: number) => ApplyPatchExtraction;
+};
+export type ApplyPatchRecordActionContext = ApplyPatchActionContext & {
+    record: UnknownRecord;
+};

package/dist/tools/apply-patch/args-normalizer/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -7,6 +7,7 @@ export const looksLikePatch = (text) => {
     return (t.includes('*** Begin Patch') ||
         t.includes('*** Update File:') ||
         t.includes('*** Add File:') ||
+        t.includes('*** Create File:') ||
         t.includes('*** Delete File:') ||
         t.includes('diff --git') ||
         /^(?:@@|\+\+\+\s|---\s)/m.test(t));

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

@@ -53,6 +53,77 @@ const convertUnifiedDiffToApplyPatchIfPossible = (text) => {
         return null;
     }
 };
+const convertStarHeaderDiffToApplyPatchIfPossible = (text) => {
+    try {
+        if (!text || text.includes('*** Begin Patch') || text.includes('diff --git'))
+            return null;
+        const lines = text.replace(/\r\n/g, '\n').split('\n');
+        if (lines.length < 3)
+            return null;
+        const first = String(lines[0] ?? '').trim();
+        const second = String(lines[1] ?? '').trim();
+        if (!first.startsWith('*** ') || !second.startsWith('--- '))
+            return null;
+        if (first.startsWith('*** Add File:') || first.startsWith('*** Update File:') || first.startsWith('*** Delete File:')) {
+            return null;
+        }
+        if (!lines.some((line) => line.startsWith('@@')))
+            return null;
+        const normalizeHeaderPath = (value) => {
+            const v = String(value || '').trim().replace(/\s+\*\*\*$/g, '').trim();
+            if (!v)
+                return '';
+            const m = v.match(/^(?:a\/|b\/)?(.+)$/);
+            return (m && m[1] ? m[1] : v).trim();
+        };
+        const oldPath = normalizeHeaderPath(first.slice(4));
+        const newPath = normalizeHeaderPath(second.slice(4));
+        const body = lines.slice(2);
+        const out = ['*** Begin Patch'];
+        if (oldPath === '/dev/null' && newPath && newPath !== '/dev/null') {
+            out.push(`*** Add File: ${newPath}`);
+            for (const line of body) {
+                if (line.startsWith('+')) {
+                    out.push(line);
+                }
+            }
+            out.push('*** End Patch');
+            return out.join('\n');
+        }
+        if (newPath === '/dev/null' && oldPath && oldPath !== '/dev/null') {
+            out.push(`*** Delete File: ${oldPath}`);
+            out.push('*** End Patch');
+            return out.join('\n');
+        }
+        const filePath = newPath || oldPath;
+        if (!filePath)
+            return null;
+        out.push(`*** Update File: ${filePath}`);
+        for (const line of body) {
+            out.push(line);
+        }
+        out.push('*** End Patch');
+        return out.join('\n');
+    }
+    catch {
+        return null;
+    }
+};
+const normalizeApplyPatchFileHeader = (line) => {
+    const addMatch = line.match(/^\*\*\* Add File:\s*(.+?)(?:\s+\*\*\*)?\s*$/);
+    if (addMatch && addMatch[1]) {
+        return `*** Add File: ${addMatch[1].trim()}`;
+    }
+    const updateMatch = line.match(/^\*\*\* Update File:\s*(.+?)(?:\s+\*\*\*)?\s*$/);
+    if (updateMatch && updateMatch[1]) {
+        return `*** Update File: ${updateMatch[1].trim()}`;
+    }
+    const deleteMatch = line.match(/^\*\*\* Delete File:\s*(.+?)(?:\s+\*\*\*)?\s*$/);
+    if (deleteMatch && deleteMatch[1]) {
+        return `*** Delete File: ${deleteMatch[1].trim()}`;
+    }
+    return line;
+};
 const stripCodeFences = (text) => {
     const trimmed = text.trim();
     // Only treat the entire payload as fenced when it *starts* with a code fence.
@@ -152,7 +223,12 @@ export const normalizeApplyPatchText = (raw) => {
         if (converted)
             text = converted;
     }
-    else if (!text.includes('*** Begin Patch') &&
+    else if (!text.includes('*** Begin Patch') && !text.includes('diff --git')) {
+        const converted = convertStarHeaderDiffToApplyPatchIfPossible(text);
+        if (converted)
+            text = converted;
+    }
+    if (!text.includes('*** Begin Patch') &&
         !text.includes('diff --git') &&
         text.includes('***************') &&
         /^\*\*\*\s+\S+/m.test(text) &&
@@ -172,9 +248,11 @@ export const normalizeApplyPatchText = (raw) => {
         if (converted)
             text = converted;
     }
-    if (text.includes('*** Add File:')) {
-        text = text.replace(/\*\*\* Create File:/g, '*** Add File:');
-    }
+    text = text.replace(/\*\*\* Create File:/g, '*** Add File:');
+    text = text
+        .split('\n')
+        .map((line) => normalizeApplyPatchFileHeader(line))
+        .join('\n');
     let hasBegin = text.includes('*** Begin Patch');
     const hasEnd = text.includes('*** End Patch');
     if (hasBegin && !hasEnd) {
@@ -216,29 +294,41 @@ export const normalizeApplyPatchText = (raw) => {
     const lines = text.split('\n');
     const output = [];
     let inUpdateSection = false;
+    let inAddSection = false;
     let afterUpdateHeader = false;
     for (const line of lines) {
         if (line.startsWith('*** Begin Patch')) {
             output.push(line);
             inUpdateSection = false;
+            inAddSection = false;
             afterUpdateHeader = false;
             continue;
         }
         if (line.startsWith('*** End Patch')) {
             output.push(line);
             inUpdateSection = false;
+            inAddSection = false;
             afterUpdateHeader = false;
             continue;
         }
         if (line.startsWith('*** Update File:')) {
             output.push(line);
             inUpdateSection = true;
+            inAddSection = false;
             afterUpdateHeader = true;
             continue;
         }
-        if (line.startsWith('*** Add File:') || line.startsWith('*** Delete File:')) {
+        if (line.startsWith('*** Add File:')) {
             output.push(line);
             inUpdateSection = false;
+            inAddSection = true;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** Delete File:')) {
+            output.push(line);
+            inUpdateSection = false;
+            inAddSection = false;
             afterUpdateHeader = false;
             continue;
         }
@@ -255,6 +345,15 @@ export const normalizeApplyPatchText = (raw) => {
             }
             continue;
         }
+        if (inAddSection) {
+            if (line.startsWith('+')) {
+                output.push(line);
+            }
+            else {
+                output.push(`+${line}`);
+            }
+            continue;
+        }
         output.push(line);
     }
     return output.join('\n');

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

@@ -1,6 +1,22 @@
 import { isStructuredApplyPatchPayload } from '../structured.js';
 import { tryParseJson } from '../json/parse-loose.js';
 import { asString } from '../validation/shared.js';
+const resolveTopLevelFile = (record) => {
+    const direct = asString(record.file) ??
+        asString(record.path) ??
+        asString(record.filepath) ??
+        asString(record.filename);
+    if (direct)
+        return direct;
+    const targetAlias = asString(record.target);
+    if (!targetAlias)
+        return undefined;
+    if (targetAlias.includes('\n') || targetAlias.includes('\r'))
+        return undefined;
+    if (!/[./\\]/.test(targetAlias))
+        return undefined;
+    return targetAlias;
+};
 const buildSingleChangePayload = (record) => {
     const kindRaw = asString(record.kind);
     if (!kindRaw)
@@ -14,7 +30,11 @@ const buildSingleChangePayload = (record) => {
     if (typeof record.use_anchor_indent === 'boolean') {
         change.use_anchor_indent = record.use_anchor_indent;
     }
-    const changeFile = asString(record.file);
+    const changeFile = asString(record.file) ??
+        asString(record.path) ??
+        asString(record.filepath) ??
+        asString(record.filename) ??
+        resolveTopLevelFile(record);
     if (changeFile) {
         change.file = changeFile;
     }
@@ -44,7 +64,11 @@ const coerceChangesArray = (value) => {
     return undefined;
 };
 export const coerceStructuredPayload = (record) => {
+    const topLevelFile = resolveTopLevelFile(record);
     if (isStructuredApplyPatchPayload(record)) {
+        if (topLevelFile && !asString(record.file)) {
+            return { ...record, file: topLevelFile };
+        }
         return record;
     }
     if (Array.isArray(record.changes) && record.changes.length === 0) {
@@ -55,7 +79,7 @@ export const coerceStructuredPayload = (record) => {
         const changesFromInstructions = coerceChangesArray(record.instructions);
         if (changesFromInstructions) {
             return {
-                ...(typeof record.file === 'string' ? { file: record.file } : {}),
+                ...(topLevelFile ? { file: topLevelFile } : {}),
                 changes: changesFromInstructions
             };
         }
@@ -63,14 +87,14 @@ export const coerceStructuredPayload = (record) => {
         const changesFromString = coerceChangesArray(record.changes);
         if (changesFromString) {
             return {
-                ...(typeof record.file === 'string' ? { file: record.file } : {}),
+                ...(topLevelFile ? { file: topLevelFile } : {}),
                 changes: changesFromString
             };
         }
         const editsFromString = coerceChangesArray(record.edits ?? record.operations ?? record.ops);
         if (editsFromString) {
             return {
-                ...(typeof record.file === 'string' ? { file: record.file } : {}),
+                ...(topLevelFile ? { file: topLevelFile } : {}),
                 changes: editsFromString
             };
         }