@jsonstudio/rcc 0.90.876 → 0.90.1270

package/node_modules/@jsonstudio/llms/dist/telemetry/stats-center.js

@@ -1,6 +1,26 @@
 import path from 'node:path';
 import fs from 'node:fs/promises';
 import { resolveRccPath } from '../runtime/user-data-paths.js';
+function formatUnknownError(error) {
+    if (error instanceof Error) {
+        return error.stack || `${error.name}: ${error.message}`;
+    }
+    try {
+        return JSON.stringify(error);
+    }
+    catch {
+        return String(error);
+    }
+}
+function logStatsCenterNonBlockingError(stage, error, details) {
+    try {
+        const suffix = details && Object.keys(details).length > 0 ? ` details=${JSON.stringify(details)}` : '';
+        console.warn(`[stats-center] ${stage} failed (non-blocking): ${formatUnknownError(error)}${suffix}`);
+    }
+    catch {
+        // Never throw from non-blocking logging.
+    }
+}
 function createEmptyRouterBucket() {
     return {
         requestCount: 0,
@@ -120,8 +140,10 @@ class DefaultStatsCenter {
             await fs.writeFile(this.persistPath, payload, 'utf-8');
             this.dirty = false;
         }
-        catch {
-            // ignore persistence errors
+        catch (persistError) {
+            logStatsCenterNonBlockingError('flushToDisk', persistError, {
+                persistPath: this.persistPath
+            });
         }
         finally {
             this.flushInFlight = false;
@@ -268,34 +290,34 @@ export function initStatsCenter(options) {
             try {
                 await center.flushToDisk();
             }
-            catch {
-                // ignore
+            catch (flushError) {
+                logStatsCenterNonBlockingError('beforeExit.flushToDisk', flushError);
             }
             try {
                 const snapshot = center.getSnapshot();
                 printStatsToConsole(snapshot);
             }
-            catch {
-                // ignore
+            catch (printError) {
+                logStatsCenterNonBlockingError('beforeExit.printStatsToConsole', printError);
             }
         };
         try {
             process.once('beforeExit', handler);
         }
-        catch {
-            // ignore
+        catch (bindBeforeExitError) {
+            logStatsCenterNonBlockingError('bind.beforeExit', bindBeforeExitError);
         }
         try {
             process.once('SIGINT', handler);
         }
-        catch {
-            // ignore
+        catch (bindSigintError) {
+            logStatsCenterNonBlockingError('bind.SIGINT', bindSigintError);
         }
         try {
             process.once('SIGTERM', handler);
         }
-        catch {
-            // ignore
+        catch (bindSigtermError) {
+            logStatsCenterNonBlockingError('bind.SIGTERM', bindSigtermError);
         }
     }
     return instance;

package/node_modules/@jsonstudio/llms/dist/tools/apply-patch/patch-text/fuzzy-match.d.ts

@@ -0,0 +1,14 @@
+export interface FuzzyMatchResult {
+    startLine: number;
+    endLine: number;
+    strategy: string;
+    similarity: number;
+}
+export interface FuzzyFindResult {
+    newContent: string;
+    matchCount: number;
+    error?: string;
+    strategyUsed?: string;
+}
+export declare function fuzzyFindAndReplace(content: string, oldString: string, newString: string, replaceAll?: boolean): FuzzyFindResult;
+export declare function fuzzyFindInLines(contentLines: string[], patternLines: string[], threshold?: number): FuzzyMatchResult[];

package/node_modules/@jsonstudio/llms/dist/tools/apply-patch/patch-text/fuzzy-match.js

@@ -0,0 +1,174 @@
+// fuzzy-match.ts - Multi-strategy fuzzy matching for apply_patch
+export function fuzzyFindAndReplace(content, oldString, newString, replaceAll = false) {
+    if (!oldString) {
+        return { newContent: content, matchCount: 0, error: 'old_string cannot be empty' };
+    }
+    if (oldString === newString) {
+        return { newContent: content, matchCount: 0, error: 'old_string and new_string are identical' };
+    }
+    const strategies = [
+        ['exact', strategyExact],
+        ['line_trimmed', strategyLineTrimmed],
+        ['whitespace_normalized', strategyWhitespaceNormalized],
+        ['indentation_flexible', strategyIndentationFlexible],
+        ['escape_normalized', strategyEscapeNormalized],
+        ['trimmed_boundary', strategyTrimmedBoundary],
+        ['block_anchor', strategyBlockAnchor],
+        ['context_aware', strategyContextAware],
+    ];
+    for (const [name, fn] of strategies) {
+        const matches = fn(content, oldString);
+        if (matches.length > 0) {
+            if (matches.length > 1 && !replaceAll) {
+                return { newContent: content, matchCount: 0, error: `Found ${matches.length} matches` };
+            }
+            return { newContent: applyReplacements(content, matches, newString), matchCount: matches.length, strategyUsed: name };
+        }
+    }
+    return { newContent: content, matchCount: 0, error: 'No match found' };
+}
+export function fuzzyFindInLines(contentLines, patternLines, threshold = 0.10) {
+    if (!patternLines.length || !contentLines.length)
+        return [];
+    const strategies = [
+        ['exact', strategyLinesExact],
+        ['line_trimmed', strategyLinesTrimmed],
+        ['indentation_flexible', strategyLinesIndentationFlexible],
+        ['block_anchor', strategyLinesBlockAnchor],
+        ['context_aware', strategyLinesContextAware],
+    ];
+    for (const [, fn] of strategies) {
+        const matches = fn(contentLines, patternLines);
+        const filtered = matches.filter(m => m.similarity >= threshold);
+        if (filtered.length > 0)
+            return filtered;
+    }
+    return [];
+}
+function strategyExact(content, pattern) {
+    const idx = content.indexOf(pattern);
+    if (idx === -1)
+        return [];
+    const startLine = content.substring(0, idx).split('\n').length - 1;
+    const endLine = startLine + pattern.split('\n').length;
+    return [{ startLine, endLine, strategy: 'exact', similarity: 1.0 }];
+}
+function strategyLineTrimmed(content, pattern) {
+    return strategyLinesTrimmed(content.split('\n'), pattern.split('\n'));
+}
+function strategyWhitespaceNormalized(content, pattern) {
+    const norm = (s) => s.replace(/\s+/g, ' ').trim();
+    const cLines = content.split('\n').map(norm);
+    const pLines = pattern.split('\n').map(norm);
+    const matches = findExactLineSequence(cLines, pLines);
+    return matches.map(m => ({ ...m, strategy: 'whitespace_normalized', similarity: 0.90 }));
+}
+function strategyIndentationFlexible(content, pattern) {
+    return strategyLinesIndentationFlexible(content.split('\n'), pattern.split('\n'));
+}
+function strategyEscapeNormalized(content, pattern) {
+    const decode = (s) => s.replace(/\\r\\n/g, '\n').replace(/\\r/g, '\n').replace(/\\n/g, '\n');
+    if (!content.includes('\\n') && !pattern.includes('\\n'))
+        return [];
+    return strategyExact(decode(content), decode(pattern));
+}
+function strategyTrimmedBoundary(content, pattern) {
+    const cLines = content.split('\n');
+    const pLines = pattern.split('\n');
+    if (pLines.length < 2)
+        return [];
+    const tc = cLines.map((l, i) => (i === 0 || i === cLines.length - 1) ? l.trim() : l);
+    const tp = pLines.map((l, i) => (i === 0 || i === pLines.length - 1) ? l.trim() : l);
+    return findExactLineSequence(tc, tp).map(m => ({ ...m, strategy: 'trimmed_boundary', similarity: 0.95 }));
+}
+function strategyBlockAnchor(content, pattern) {
+    return strategyLinesBlockAnchor(content.split('\n'), pattern.split('\n'));
+}
+function strategyContextAware(content, pattern) {
+    return strategyLinesContextAware(content.split('\n'), pattern.split('\n'));
+}
+function strategyLinesExact(cLines, pLines) {
+    return findExactLineSequence(cLines, pLines).map(m => ({ ...m, strategy: 'exact', similarity: 1.0 }));
+}
+function strategyLinesTrimmed(cLines, pLines) {
+    return findExactLineSequence(cLines.map(l => l.trim()), pLines.map(l => l.trim()))
+        .map(m => ({ ...m, strategy: 'line_trimmed', similarity: 0.95 }));
+}
+function strategyLinesIndentationFlexible(cLines, pLines) {
+    return findExactLineSequence(cLines.map(l => l.trim()), pLines.map(l => l.trim()))
+        .map(m => ({ ...m, strategy: 'indentation_flexible', similarity: 0.85 }));
+}
+function strategyLinesBlockAnchor(cLines, pLines) {
+    if (pLines.length < 2)
+        return [];
+    const firstP = pLines[0].trim();
+    const lastP = pLines[pLines.length - 1].trim();
+    const len = pLines.length;
+    const potentials = [];
+    for (let i = 0; i <= cLines.length - len; i++) {
+        if (cLines[i].trim() === firstP && cLines[i + len - 1].trim() === lastP)
+            potentials.push(i);
+    }
+    const results = [];
+    for (const start of potentials) {
+        const sim = len <= 2 ? 1.0 : calculateSimilarity(cLines.slice(start + 1, start + len - 1).join('\n'), pLines.slice(1, -1).join('\n'));
+        if (sim >= (potentials.length === 1 ? 0.10 : 0.30)) {
+            results.push({ startLine: start, endLine: start + len, strategy: 'block_anchor', similarity: sim });
+        }
+    }
+    return results;
+}
+function strategyLinesContextAware(cLines, pLines) {
+    const len = pLines.length;
+    const results = [];
+    for (let i = 0; i <= cLines.length - len; i++) {
+        const block = cLines.slice(i, i + len);
+        let highSim = 0;
+        for (let j = 0; j < len; j++) {
+            if (calculateSimilarity(pLines[j].trim(), block[j].trim()) >= 0.80)
+                highSim++;
+        }
+        if (highSim >= len * 0.5) {
+            results.push({ startLine: i, endLine: i + len, strategy: 'context_aware', similarity: highSim / len });
+        }
+    }
+    return results;
+}
+function findExactLineSequence(hay, needle) {
+    if (!needle.length)
+        return [];
+    const results = [];
+    for (let i = 0; i <= hay.length - needle.length; i++) {
+        let match = true;
+        for (let j = 0; j < needle.length; j++) {
+            if (hay[i + j] !== needle[j]) {
+                match = false;
+                break;
+            }
+        }
+        if (match)
+            results.push({ startLine: i, endLine: i + needle.length });
+    }
+    return results;
+}
+function applyReplacements(content, matches, newStr) {
+    const lines = content.split('\n');
+    for (const m of [...matches].sort((a, b) => b.startLine - a.startLine)) {
+        lines.splice(m.startLine, m.endLine - m.startLine, ...newStr.split('\n'));
+    }
+    return lines.join('\n');
+}
+function calculateSimilarity(a, b) {
+    if (a === b)
+        return 1.0;
+    if (!a || !b)
+        return 0.0;
+    const aChars = a.split('');
+    const bChars = b.split('');
+    const bSet = new Set(bChars);
+    const intersectionSize = aChars.filter(c => bSet.has(c)).length;
+    const aSetSize = new Set(aChars).size;
+    const bSetSize = bSet.size;
+    const unionSize = aSetSize + bSetSize - intersectionSize;
+    return unionSize > 0 ? intersectionSize / unionSize : 0.0;
+}

package/node_modules/@jsonstudio/llms/dist/tools/apply-patch/patch-text/normalize.js

@@ -385,6 +385,153 @@ const repairMissingHunkHeaderSafely = (patchText) => {
         return patchText;
     }
 };
+const repairLegacyContextDiffHunksInsideApplyPatchEnvelope = (patchText) => {
+    try {
+        const lines = patchText.split('\n');
+        const out = [];
+        const legacyOldHeaderRe = /^\*\*\*\s+\d+(?:,\d+)?(?:\s+\*{3,4})?\s*$/;
+        const legacyNewHeaderRe = /^---\s+\d+(?:,\d+)?(?:\s+-{3,4})?\s*$/;
+        const decodeLegacyOldLine = (raw) => {
+            const lineText = String(raw ?? '');
+            const lead = lineText[0] ?? '';
+            if (lead === '!' || lead === '-') {
+                let rest = lineText.slice(1);
+                if (rest.startsWith(' '))
+                    rest = rest.slice(1);
+                return { kind: 'delete', text: rest };
+            }
+            if (lead === ' ') {
+                return { kind: 'context', text: lineText.slice(1) };
+            }
+            return { kind: 'context', text: lineText };
+        };
+        const decodeLegacyNewLine = (raw) => {
+            const lineText = String(raw ?? '');
+            const lead = lineText[0] ?? '';
+            if (lead === '!' || lead === '+') {
+                let rest = lineText.slice(1);
+                if (rest.startsWith(' '))
+                    rest = rest.slice(1);
+                return { kind: 'add', text: rest };
+            }
+            if (lead === ' ') {
+                return { kind: 'context', text: lineText.slice(1) };
+            }
+            return { kind: 'add', text: lineText };
+        };
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i] ?? '';
+            const updateMatch = line.match(/^\*\*\* Update File:\s*(.+)$/);
+            if (!updateMatch) {
+                out.push(line);
+                i += 1;
+                continue;
+            }
+            const filePath = normalizeApplyPatchHeaderPath(String(updateMatch[1] ?? '').trim());
+            const sectionBody = [];
+            i += 1;
+            while (i < lines.length) {
+                const next = lines[i] ?? '';
+                if (next.startsWith('*** Update File:') ||
+                    next.startsWith('*** Add File:') ||
+                    next.startsWith('*** Delete File:') ||
+                    next.startsWith('*** End Patch')) {
+                    break;
+                }
+                sectionBody.push(next);
+                i += 1;
+            }
+            const hasModernHunk = sectionBody.some((entry) => entry.startsWith('@@'));
+            const hasLegacyContextHeader = sectionBody.some((entry) => legacyOldHeaderRe.test(entry));
+            const hasLegacyContextOtherSide = sectionBody.some((entry) => legacyNewHeaderRe.test(entry));
+            if (!hasModernHunk && hasLegacyContextHeader && hasLegacyContextOtherSide && filePath && filePath !== '/dev/null') {
+                const convertedSectionBody = [];
+                let j = 0;
+                let convertedAny = false;
+                while (j < sectionBody.length) {
+                    const current = sectionBody[j] ?? '';
+                    if (!legacyOldHeaderRe.test(current)) {
+                        convertedSectionBody.push(current);
+                        j += 1;
+                        continue;
+                    }
+                    j += 1;
+                    const oldLines = [];
+                    while (j < sectionBody.length && !legacyNewHeaderRe.test(sectionBody[j] ?? '')) {
+                        if (legacyOldHeaderRe.test(sectionBody[j] ?? ''))
+                            break;
+                        oldLines.push(sectionBody[j] ?? '');
+                        j += 1;
+                    }
+                    if (j >= sectionBody.length || !legacyNewHeaderRe.test(sectionBody[j] ?? '')) {
+                        convertedSectionBody.push(current, ...oldLines);
+                        break;
+                    }
+                    j += 1;
+                    const newLines = [];
+                    while (j < sectionBody.length && !legacyOldHeaderRe.test(sectionBody[j] ?? '')) {
+                        newLines.push(sectionBody[j] ?? '');
+                        j += 1;
+                    }
+                    convertedSectionBody.push('@@');
+                    const oldOps = oldLines.map(decodeLegacyOldLine);
+                    const newOps = newLines.map(decodeLegacyNewLine);
+                    let oi = 0;
+                    let ni = 0;
+                    while (oi < oldOps.length || ni < newOps.length) {
+                        const o = oi < oldOps.length ? oldOps[oi] : null;
+                        const n = ni < newOps.length ? newOps[ni] : null;
+                        if (o && n && o.kind === 'context' && n.kind === 'context' && o.text === n.text) {
+                            convertedSectionBody.push(` ${o.text}`);
+                            oi += 1;
+                            ni += 1;
+                            continue;
+                        }
+                        if (o && o.kind === 'delete') {
+                            convertedSectionBody.push(`-${o.text}`);
+                            oi += 1;
+                            if (n && n.kind === 'add') {
+                                convertedSectionBody.push(`+${n.text}`);
+                                ni += 1;
+                            }
+                            continue;
+                        }
+                        if (n && n.kind === 'add') {
+                            convertedSectionBody.push(`+${n.text}`);
+                            ni += 1;
+                            continue;
+                        }
+                        if (o && o.kind === 'context') {
+                            convertedSectionBody.push(` ${o.text}`);
+                            oi += 1;
+                            continue;
+                        }
+                        if (n && n.kind === 'context') {
+                            convertedSectionBody.push(` ${n.text}`);
+                            ni += 1;
+                            continue;
+                        }
+                        if (o)
+                            oi += 1;
+                        if (n)
+                            ni += 1;
+                    }
+                    convertedAny = true;
+                }
+                if (convertedAny) {
+                    out.push(`*** Update File: ${filePath}`, ...convertedSectionBody);
+                    continue;
+                }
+            }
+            out.push(line, ...sectionBody);
+        }
+        return out.join('\n');
+    }
+    catch {
+        return patchText;
+    }
+};
 const isIgnorableGitMetadataLineInUpdateSection = (line) => {
     return (line.startsWith('diff --git ') ||
         line.startsWith('index ') ||
@@ -483,6 +630,7 @@ export const normalizeApplyPatchText = (raw) => {
         .split('\n')
         .map((line) => normalizeApplyPatchFileHeader(line))
         .join('\n');
+    text = repairLegacyContextDiffHunksInsideApplyPatchEnvelope(text);
     let hasBegin = text.includes('*** Begin Patch');
     const hasEnd = text.includes('*** End Patch');
     if (hasBegin && !hasEnd) {

package/node_modules/@jsonstudio/llms/dist/tools/apply-patch/structured.js

@@ -1,3 +1,4 @@
+import { fuzzyFindInLines } from './patch-text/fuzzy-match.js';
 export class StructuredApplyPatchError extends Error {
     reason;
     constructor(reason, message) {
@@ -153,6 +154,26 @@ const findSubsequence = (haystack, needle) => {
     }
     return -1;
 };
+/**
+ * Fuzzy-enhanced subsequence finder
+ * Falls back to fuzzy matching strategies when exact match fails
+ */
+const findSubsequenceWithFuzzy = (haystack, needle) => {
+    const exactIndex = findSubsequence(haystack, needle);
+    if (exactIndex >= 0)
+        return { index: exactIndex, strategy: "exact" };
+    // Fallback to fuzzy matching
+    const fuzzyMatches = fuzzyFindInLines(haystack, needle, 0.15);
+    if (fuzzyMatches.length === 1) {
+        return { index: fuzzyMatches[0].startLine, strategy: fuzzyMatches[0].strategy };
+    }
+    if (fuzzyMatches.length > 1) {
+        // Multiple fuzzy matches - pick the highest similarity
+        const best = fuzzyMatches.reduce((a, b) => a.similarity > b.similarity ? a : b);
+        return { index: best.startLine, strategy: best.strategy };
+    }
+    return { index: -1 };
+};
 const tryApplyToFileLines = (section, kindRaw, change, changeRec, index) => {
     const lines = section.lines;
     if (kindRaw === 'insert_after' || kindRaw === 'insert_before') {
@@ -167,7 +188,11 @@ const tryApplyToFileLines = (section, kindRaw, change, changeRec, index) => {
             change.before_text;
         const anchor = toSafeString(anchorSource, `changes[${index}].anchor`);
         const anchorLines = splitTextIntoLines(anchor);
-        const anchorIndex = findSubsequence(lines, anchorLines);
+        const anchorResult = findSubsequenceWithFuzzy(lines, anchorLines);
+        const anchorIndex = anchorResult.index;
+        if (anchorResult.strategy !== "exact" && anchorResult.strategy) {
+            console.log(`[apply_patch] fuzzy match applied for anchor: strategy=${anchorResult.strategy}`);
+        }
         if (anchorIndex < 0) {
             // 兼容性增强：保持原语义（返回 false），避免抛异常
             return false;
@@ -204,7 +229,11 @@ const tryApplyToFileLines = (section, kindRaw, change, changeRec, index) => {
             change.before_text;
         const target = toSafeString(targetSource, `changes[${index}].target`);
         const targetLines = splitTextIntoLines(target);
-        const targetIndex = findSubsequence(lines, targetLines);
+        const targetResult = findSubsequenceWithFuzzy(lines, targetLines);
+        const targetIndex = targetResult.index;
+        if (targetResult.strategy !== "exact" && targetResult.strategy) {
+            console.log(`[apply_patch] fuzzy match applied for target: strategy=${targetResult.strategy}`);
+        }
         if (targetIndex < 0) {
             // 兼容性增强：保持原语义（返回 false），避免抛异常
             return false;

package/node_modules/@jsonstudio/llms/dist/tools/apply-patch/validator.js

@@ -1,4 +1,5 @@
 import { normalizeApplyPatchArgs } from './args-normalizer/index.js';
+import { fixApplyPatchToolCallsWithNative } from '../../router/virtual-router/engine-selection/native-compat-action-semantics.js';
 import { normalizeApplyPatchText, looksLikePatch } from './patch-text/normalize.js';
 export { looksLikePatch, normalizeApplyPatchText };
 const toJson = (value) => {
@@ -9,10 +10,119 @@ const toJson = (value) => {
         return '{}';
     }
 };
+function readString(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value : undefined;
+}
+function normalizeApplyPatchArgsWithNative(rawArgs) {
+    try {
+        const fixed = fixApplyPatchToolCallsWithNative({
+            input: [
+                {
+                    type: 'function_call',
+                    name: 'apply_patch',
+                    arguments: typeof rawArgs === 'string' ? rawArgs : String(rawArgs ?? '')
+                }
+            ]
+        });
+        const normalized = fixed.input?.[0]?.arguments;
+        return readString(normalized);
+    }
+    catch {
+        return undefined;
+    }
+}
+function inferFailureReasonFromPatch(normalizedPatch) {
+    const patch = typeof normalizedPatch === 'string' ? normalizedPatch : '';
+    if (!patch.trim()) {
+        return 'missing_changes';
+    }
+    if (/^\*\*\* Add File:\s*\/dev\/null\s*$/m.test(patch)
+        || /^\*\*\* Update File:\s*\/dev\/null\s*$/m.test(patch)
+        || /^\*\*\* Delete File:\s*\/dev\/null\s*$/m.test(patch)) {
+        return 'invalid_patch_path';
+    }
+    if (/^\*\*\* Add File:/m.test(patch) && !/^\+/m.test(patch)) {
+        return 'empty_add_file_block';
+    }
+    if (/^\*\*\* Update File:/m.test(patch) && !/^\@\@/m.test(patch) && !/^\*\*\* Move to:/m.test(patch)) {
+        return 'unsupported_patch_format';
+    }
+    if (/^\@\@/m.test(patch) && !/^[ +-]/m.test(patch)) {
+        return 'empty_update_hunk';
+    }
+    return 'unsupported_patch_format';
+}
+function hasUnsafeMixedSyntaxInsideAddFile(normalizedPatch) {
+    const patch = typeof normalizedPatch === 'string' ? normalizedPatch : '';
+    if (!patch) {
+        return false;
+    }
+    const lines = patch.split('\n');
+    let inAddSection = false;
+    for (const line of lines) {
+        if (line.startsWith('*** Add File:')) {
+            inAddSection = true;
+            continue;
+        }
+        if (line.startsWith('*** Update File:') || line.startsWith('*** Delete File:') || line.startsWith('*** End Patch')) {
+            inAddSection = false;
+            continue;
+        }
+        if (!inAddSection) {
+            continue;
+        }
+        if (/^\+\@\@(?:\s|$)/.test(line)) {
+            return true;
+        }
+        if (/^\+(?:diff --git |index |--- |\+\+\+ )/.test(line)) {
+            return true;
+        }
+    }
+    return false;
+}
 export function validateApplyPatchArgs(argsString, rawArgs) {
-    const normalized = normalizeApplyPatchArgs(argsString, rawArgs);
-    if (normalized.ok === false) {
-        const reason = normalized.reason;
+    const nativeNormalizedArgs = normalizeApplyPatchArgsWithNative(typeof argsString === 'string' && argsString.trim().length > 0
+        ? argsString
+        : String(rawArgs ?? ''));
+    let normalizedPatch;
+    if (nativeNormalizedArgs) {
+        try {
+            const parsed = JSON.parse(nativeNormalizedArgs);
+            normalizedPatch = readString(parsed.patch) ?? readString(parsed.input);
+        }
+        catch {
+            normalizedPatch = undefined;
+        }
+    }
+    if (!normalizedPatch || !looksLikePatch(normalizedPatch)) {
+        const normalized = normalizeApplyPatchArgs(argsString, rawArgs);
+        if (normalized.ok === false) {
+            const reason = normalized.reason;
+            let message;
+            if (reason === 'missing_changes') {
+                message = '结构完整但无内容';
+            }
+            else if (reason === 'empty_add_file_block') {
+                message = 'Add File 不能为空文件；请提供至少一行以 + 开头的内容';
+            }
+            else if (reason === 'empty_update_hunk') {
+                message = 'Update File 的 @@ hunk 不能为空；请在 @@ 后提供至少一行以空格/+/-开头的内容';
+            }
+            else if (reason === 'invalid_patch_path') {
+                message = '文件路径非法：请使用精确路径，禁止 /dev/null 作为 Add/Update/Delete File 路径';
+            }
+            else if (reason === 'unsupported_patch_format') {
+                message = '补丁格式不合法：Update File 必须包含 @@ hunk，且不要猜测文件名/参数；若要整文件重写，请显式 Delete File + Add File（每行加 +）';
+            }
+            return { ok: false, reason, message };
+        }
+        normalizedPatch = normalized.patchText;
+    }
+    if (normalizedPatch) {
+        normalizedPatch = normalizeApplyPatchText(normalizedPatch);
+    }
+    if (!normalizedPatch || !looksLikePatch(normalizedPatch)) {
+        const reason = inferFailureReasonFromPatch(normalizedPatch);
         let message;
         if (reason === 'missing_changes') {
             message = '结构完整但无内容';
@@ -31,8 +141,15 @@ export function validateApplyPatchArgs(argsString, rawArgs) {
         }
         return { ok: false, reason, message };
     }
+    if (hasUnsafeMixedSyntaxInsideAddFile(normalizedPatch)) {
+        return {
+            ok: false,
+            reason: 'unsupported_patch_format',
+            message: '补丁格式不合法：Add File 块中混入了 diff/hunk 头；这会写坏文件。请改成纯 Add File 内容，或改成正确的 unified diff 后重试'
+        };
+    }
     return {
         ok: true,
-        normalizedArgs: toJson({ patch: normalized.patchText, input: normalized.patchText })
+        normalizedArgs: toJson({ patch: normalizedPatch, input: normalizedPatch })
     };
 }

package/node_modules/@jsonstudio/llms/dist/tools/exec-command/normalize.d.ts

@@ -7,5 +7,8 @@ export type ExecCommandNormalizeResult = {
     reason: 'missing_cmd';
     normalized: UnknownRecord;
 };
-export declare function normalizeExecCommandArgs(args: unknown): ExecCommandNormalizeResult;
+export type ExecCommandNormalizeOptions = {
+    schemaMode?: 'compat' | 'canonical';
+};
+export declare function normalizeExecCommandArgs(args: unknown, options?: ExecCommandNormalizeOptions): ExecCommandNormalizeResult;
 export {};