@jsonstudio/llms 0.6.753 → 0.6.802

package/dist/tools/apply-patch/regression-capturer.js

@@ -0,0 +1,112 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createHash } from 'crypto';
+/**
+ * Captures apply_patch payload regressions into a golden samples structure.
+ *
+ * Trigger: apply_patch validation failure OR fixer failure
+ * Condition: non-context errors only (format/json/prefix/etc.)
+ *
+ * Default destination:
+ *   ~/.routecodex/golden_samples/ci-regression/apply_patch/<error-type>/
+ *
+ * Optional repo destination (explicit opt-in):
+ *   ROUTECODEX_APPLY_PATCH_REGRESSION_TO_REPO=1
+ *   → <repoRoot>/samples/ci-goldens/_regressions/apply_patch/<error-type>/
+ *
+ * Explicit override:
+ *   ROUTECODEX_APPLY_PATCH_REGRESSION_DIR=/abs/path
+ */
+const MAX_SAMPLES_PER_TYPE = 50;
+function detectRepoRootFromCwd() {
+    try {
+        let dir = process.cwd();
+        for (let i = 0; i < 12; i += 1) {
+            const marker = path.join(dir, 'samples', 'ci-goldens');
+            const pkg = path.join(dir, 'package.json');
+            if (fs.existsSync(marker) && fs.existsSync(pkg)) {
+                try {
+                    const raw = fs.readFileSync(pkg, 'utf-8');
+                    const json = JSON.parse(raw);
+                    if (json && typeof json === 'object' && String(json.name || '') === 'routecodex') {
+                        return dir;
+                    }
+                }
+                catch {
+                    // ignore parse errors
+                }
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // ignore
+    }
+    return null;
+}
+function resolveSamplesRoot() {
+    const explicit = String(process?.env?.ROUTECODEX_APPLY_PATCH_REGRESSION_DIR || '').trim();
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    const toRepo = String(process?.env?.ROUTECODEX_APPLY_PATCH_REGRESSION_TO_REPO || '').trim() === '1';
+    if (toRepo) {
+        const repoRoot = detectRepoRootFromCwd();
+        if (repoRoot) {
+            return path.join(repoRoot, 'samples', 'ci-goldens', '_regressions', 'apply_patch');
+        }
+    }
+    return path.join(os.homedir(), '.routecodex', 'golden_samples', 'ci-regression', 'apply_patch');
+}
+function isContextError(error) {
+    if (!error)
+        return false;
+    const lower = error.toLowerCase();
+    return (lower.includes('failed to find context') ||
+        lower.includes('failed to find expected lines') ||
+        lower.includes('file not found') ||
+        lower.includes('no such file'));
+}
+function stableSampleId(sample) {
+    const key = `${String(sample.errorType || 'unknown')}:${String(sample.originalArgs ?? '')}:` +
+        `${String(sample.normalizedArgs ?? '')}:${String(sample.fixerResult ?? '')}:${String(sample.validationError ?? '')}`;
+    return createHash('sha1').update(key).digest('hex').slice(0, 16);
+}
+export function captureApplyPatchRegression(sample) {
+    try {
+        if (isContextError(sample.validationError))
+            return;
+        const root = resolveSamplesRoot();
+        const safeType = String(sample.errorType || 'unknown').replace(/[^a-z0-9-]/gi, '_');
+        const typeDir = path.join(root, safeType);
+        if (!fs.existsSync(typeDir)) {
+            fs.mkdirSync(typeDir, { recursive: true });
+        }
+        // Check limit (best-effort; keep runtime safe)
+        try {
+            const existing = fs.readdirSync(typeDir).filter((f) => f.endsWith('.json'));
+            if (existing.length >= MAX_SAMPLES_PER_TYPE)
+                return;
+        }
+        catch {
+            // ignore
+        }
+        const id = `sample_${stableSampleId(sample)}`;
+        const file = path.join(typeDir, `${id}.json`);
+        if (fs.existsSync(file))
+            return;
+        const fullSample = {
+            id,
+            timestamp: new Date().toISOString(),
+            ...sample
+        };
+        fs.writeFileSync(file, JSON.stringify(fullSample, null, 2), 'utf-8');
+    }
+    catch {
+        // Silently fail to avoid disrupting runtime
+    }
+}

package/dist/tools/apply-patch/structured.d.ts

@@ -0,0 +1,20 @@
+export type StructuredApplyPatchKind = 'insert_after' | 'insert_before' | 'replace' | 'delete' | 'create_file' | 'delete_file';
+export interface StructuredApplyPatchChange {
+    file?: string;
+    kind: StructuredApplyPatchKind | string;
+    anchor?: string;
+    target?: string;
+    lines?: string[] | string;
+    use_anchor_indent?: boolean;
+}
+export interface StructuredApplyPatchPayload extends Record<string, unknown> {
+    instructions?: string;
+    file?: string;
+    changes: StructuredApplyPatchChange[];
+}
+export declare class StructuredApplyPatchError extends Error {
+    reason: string;
+    constructor(reason: string, message: string);
+}
+export declare function buildStructuredPatch(payload: StructuredApplyPatchPayload): string;
+export declare function isStructuredApplyPatchPayload(candidate: unknown): candidate is StructuredApplyPatchPayload;

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

@@ -0,0 +1,441 @@
+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 decodeEscapedNewlinesIfObvious = (value) => {
+    if (!value)
+        return value;
+    if (value.includes('\n'))
+        return value;
+    const lower = value.toLowerCase();
+    const looksEscaped = value.includes('\\r\\n') ||
+        (value.includes('\\n') && /\\n[ \t]/.test(value)) ||
+        lower.includes('\\u000a') ||
+        lower.includes('\\u000d');
+    if (!looksEscaped) {
+        return value;
+    }
+    let out = value;
+    out = out.replace(/\\r\\n/g, '\n');
+    out = out.replace(/\\n/g, '\n');
+    out = out.replace(/\\r/g, '\n');
+    out = out.replace(/\\u000a/gi, '\n');
+    out = out.replace(/\\u000d/gi, '\n');
+    return out;
+};
+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) => {
+    let trimmed = raw.trim();
+    if (!trimmed) {
+        throw new StructuredApplyPatchError('invalid_file', `${label} must not be empty`);
+    }
+    if (FILE_PATH_INVALID_RE.test(trimmed)) {
+        const firstLine = trimmed.split(/[\r\n]/)[0]?.trim() ?? '';
+        if (!firstLine) {
+            throw new StructuredApplyPatchError('invalid_file', `${label} must be a single-line path`);
+        }
+        trimmed = firstLine;
+    }
+    return trimmed.replace(/\\/g, '/');
+};
+const readStringish = (value) => {
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value) && value.length === 1 && typeof value[0] === 'string')
+        return String(value[0]);
+    if (value && typeof value === 'object') {
+        const rec = value;
+        const nested = readStringish(rec.path ?? rec.file ?? rec.filename ?? rec.filepath);
+        if (nested)
+            return nested;
+    }
+    return undefined;
+};
+const splitTextIntoLines = (input) => {
+    const decoded = decodeEscapedNewlinesIfObvious(input);
+    const normalized = decoded.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 [];
+        }
+        const out = [];
+        for (const [idx, entry] of value.entries()) {
+            if (typeof entry !== 'string') {
+                if (entry === null || entry === undefined) {
+                    out.push('');
+                    continue;
+                }
+                out.push(String(entry));
+                continue;
+            }
+            // Preserve intentional whitespace
+            const normalized = entry.replace(/\r/g, '');
+            const decoded = decodeEscapedNewlinesIfObvious(normalized);
+            if (decoded.includes('\n')) {
+                out.push(...splitTextIntoLines(decoded));
+            }
+            else {
+                out.push(decoded);
+            }
+        }
+        return out;
+    }
+    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 findSubsequence = (haystack, needle) => {
+    if (!needle.length)
+        return -1;
+    outer: for (let i = 0; i + needle.length <= haystack.length; i += 1) {
+        for (let j = 0; j < needle.length; j += 1) {
+            if ((haystack[i + j] ?? '') !== (needle[j] ?? ''))
+                continue outer;
+        }
+        return i;
+    }
+    return -1;
+};
+const tryApplyToFileLines = (section, kindRaw, change, changeRec, index) => {
+    const lines = section.lines;
+    if (kindRaw === 'insert_after' || kindRaw === 'insert_before') {
+        const anchorSource = change.anchor ??
+            change.target ??
+            change.context ??
+            change.from ??
+            change.old;
+        const anchor = toSafeString(anchorSource, `changes[${index}].anchor`);
+        const anchorLines = splitTextIntoLines(anchor);
+        const anchorIndex = findSubsequence(lines, anchorLines);
+        if (anchorIndex < 0)
+            return false;
+        const linesSource = changeRec.lines ?? changeRec.text ?? changeRec.content ?? changeRec.body ?? changeRec.replacement;
+        const additions = normalizeLines(linesSource, `changes[${index}].lines`);
+        if (!additions.length) {
+            throw new StructuredApplyPatchError('invalid_lines', `changes[${index}].lines must include at least one line`);
+        }
+        const prepared = kindRaw === 'insert_after'
+            ? applyAnchorIndent(additions, anchorLines, 'last', change.use_anchor_indent)
+            : applyAnchorIndent(additions, anchorLines, 'first', change.use_anchor_indent);
+        const insertAt = kindRaw === 'insert_after' ? anchorIndex + anchorLines.length : anchorIndex;
+        lines.splice(insertAt, 0, ...prepared);
+        return true;
+    }
+    if (kindRaw === 'replace' || kindRaw === 'delete') {
+        const targetSource = change.target ??
+            change.anchor ??
+            change.context ??
+            change.from ??
+            change.old;
+        const target = toSafeString(targetSource, `changes[${index}].target`);
+        const targetLines = splitTextIntoLines(target);
+        const targetIndex = findSubsequence(lines, targetLines);
+        if (targetIndex < 0)
+            return false;
+        if (kindRaw === 'delete') {
+            lines.splice(targetIndex, targetLines.length);
+            return true;
+        }
+        const linesSource = changeRec.lines ?? changeRec.text ?? changeRec.content ?? changeRec.body ?? changeRec.replacement;
+        let replacements;
+        if ((linesSource === null || linesSource === undefined) && typeof change.anchor === 'string' && typeof change.target === 'string') {
+            replacements = splitTextIntoLines(String(change.anchor));
+        }
+        else {
+            replacements = normalizeLines(linesSource, `changes[${index}].lines`);
+        }
+        lines.splice(targetIndex, targetLines.length, ...replacements);
+        return true;
+    }
+    return false;
+};
+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')
+        : typeof payload.path === 'string' && String(payload.path).trim()
+            ? normalizeFilePath(String(payload.path), 'path')
+            : typeof payload.filepath === 'string' && String(payload.filepath).trim()
+                ? normalizeFilePath(String(payload.filepath), 'filepath')
+                : typeof payload.filename === 'string' && String(payload.filename).trim()
+                    ? normalizeFilePath(String(payload.filename), 'filename')
+                    : 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 changeRec = change;
+        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 fileSource = readStringish(changeRec.file) ??
+            readStringish(changeRec.path) ??
+            readStringish(changeRec.filepath) ??
+            readStringish(changeRec.filename) ??
+            readStringish(changeRec.file_path);
+        const file = fileSource ? normalizeFilePath(fileSource, `changes[${index}].file`) : topLevelFile;
+        if (!file) {
+            throw new StructuredApplyPatchError('invalid_file', `Change at index ${index} is missing "file"`);
+        }
+        if (kindRaw === 'create_file') {
+            const linesSource = changeRec.lines ?? changeRec.text ?? changeRec.content ?? changeRec.body ?? changeRec.replacement;
+            const lines = normalizeLines(linesSource, `changes[${index}].lines`);
+            const existing = fileSections.get(file);
+            if (!existing) {
+                sectionOrder.push(file);
+                fileSections.set(file, { type: 'add', lines });
+            }
+            else if (existing.type === 'delete') {
+                // Common model behavior: delete_file + create_file for same path → treat as replace.
+                fileSections.set(file, { type: 'replace', lines });
+            }
+            else if (existing.type === 'add') {
+                // Idempotent: last create wins.
+                fileSections.set(file, { type: 'add', lines });
+            }
+            else if (existing.type === 'replace') {
+                fileSections.set(file, { type: 'replace', lines });
+            }
+            else {
+                // Existing updates imply file existed; represent as delete+add to keep a single executable path.
+                fileSections.set(file, { type: 'replace', lines });
+            }
+            continue;
+        }
+        if (kindRaw === 'delete_file') {
+            const existing = fileSections.get(file);
+            if (!existing) {
+                sectionOrder.push(file);
+                fileSections.set(file, { type: 'delete' });
+                continue;
+            }
+            if (existing.type === 'add') {
+                // create_file then delete_file → net no-op; drop the section entirely.
+                fileSections.delete(file);
+                const idx = sectionOrder.indexOf(file);
+                if (idx >= 0)
+                    sectionOrder.splice(idx, 1);
+                continue;
+            }
+            // update/replace/delete then delete_file → net delete.
+            fileSections.set(file, { type: 'delete' });
+            continue;
+        }
+        // Common shape: replace with lines but no target → treat as full-file replacement.
+        if (kindRaw === 'replace') {
+            const targetSource = change.target ?? change.anchor ?? change.context ?? change.from ?? change.old;
+            const hasTarget = typeof targetSource === 'string' && targetSource.trim().length > 0;
+            const linesSource = changeRec.lines ?? changeRec.text ?? changeRec.content ?? changeRec.body ?? changeRec.replacement;
+            const hasReplacementBody = !(linesSource === null || linesSource === undefined);
+            if (!hasTarget && hasReplacementBody) {
+                const lines = normalizeLines(linesSource, `changes[${index}].lines`);
+                const existing = fileSections.get(file);
+                if (!existing) {
+                    sectionOrder.push(file);
+                }
+                // Prefer a deterministic executable output: delete+add (replace).
+                fileSections.set(file, { type: 'replace', lines });
+                continue;
+            }
+        }
+        const existing = fileSections.get(file);
+        // Shape fix: allow create_file + subsequent structured edits by applying edits to the created content in-memory.
+        if (existing && (existing.type === 'add' || existing.type === 'replace')) {
+            const applied = tryApplyToFileLines(existing, kindRaw, change, changeRec, index);
+            if (applied) {
+                continue;
+            }
+            throw new StructuredApplyPatchError('invalid_change_sequence', `File "${file}" already marked as ${existing.type}`);
+        }
+        const section = ensureUpdateSection(file);
+        switch (kindRaw) {
+            case 'insert_after': {
+                const anchorSource = change.anchor ?? change.target ?? change.context ?? change.from ?? change.old;
+                const anchor = toSafeString(anchorSource, `changes[${index}].anchor`);
+                const anchorLines = splitTextIntoLines(anchor);
+                const linesSource = changeRec.lines ?? changeRec.text ?? changeRec.content ?? changeRec.body ?? changeRec.replacement;
+                const additions = normalizeLines(linesSource, `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 anchorSource = change.anchor ?? change.target ?? change.context ?? change.from ?? change.old;
+                const anchor = toSafeString(anchorSource, `changes[${index}].anchor`);
+                const anchorLines = splitTextIntoLines(anchor);
+                const linesSource = changeRec.lines ?? changeRec.text ?? changeRec.content ?? changeRec.body ?? changeRec.replacement;
+                const additions = normalizeLines(linesSource, `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': {
+                // 兼容仅提供 anchor 的 replace 形态：将 anchor 视为 target 以尽可能保留用户意图。
+                const targetSource = change.target ?? change.anchor ?? change.context ?? change.from ?? change.old;
+                const target = toSafeString(targetSource, `changes[${index}].target`);
+                const linesSource = changeRec.lines ?? changeRec.text ?? changeRec.content ?? changeRec.body ?? changeRec.replacement;
+                let replacements;
+                if ((linesSource === null || linesSource === undefined) && typeof change.anchor === 'string' && typeof change.target === 'string') {
+                    // Common model mistake: provide { anchor: <new>, target: <old> } but omit lines.
+                    // Treat anchor as replacement body (shape fix only).
+                    replacements = splitTextIntoLines(String(change.anchor));
+                }
+                else {
+                    replacements = normalizeLines(linesSource, `changes[${index}].lines`);
+                }
+                const hunkBody = [
+                    ...buildPrefixedLines(splitTextIntoLines(target), '-'),
+                    ...buildPrefixedLines(replacements, '+')
+                ];
+                section.hunks.push(hunkBody);
+                break;
+            }
+            case 'delete': {
+                const targetSource = change.target ?? change.anchor ?? change.context ?? change.from ?? change.old;
+                const target = toSafeString(targetSource, `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 if (section.type === 'replace') {
+            lines.push(`*** Delete File: ${file}`);
+            lines.push(`*** Add File: ${file}`);
+            for (const line of section.lines) {
+                lines.push(`+${line}`);
+            }
+        }
+        else {
+            lines.push(`*** Update File: ${file}`);
+            const hunks = section.hunks || [];
+            for (const hunk of hunks) {
+                // 结构化补丁仅负责生成统一 diff 形态，不对多段 hunk 做逻辑裁剪；
+                // 具体哪些 hunk 能成功应用由 apply_patch 客户端自行校验并返回错误信息。
+                for (const entry of hunk) {
+                    if (!entry.startsWith('@@')) {
+                        lines.push(entry);
+                    }
+                }
+            }
+        }
+    }
+    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/apply-patch/validator.d.ts

@@ -0,0 +1,8 @@
+export declare const looksLikePatch: (text?: string) => boolean;
+export declare const normalizeApplyPatchText: (raw: string) => string;
+export type ApplyPatchValidationResult = {
+    ok: boolean;
+    reason?: string;
+    normalizedArgs?: string;
+};
+export declare function validateApplyPatchArgs(argsString: string, rawArgs: unknown): ApplyPatchValidationResult;