@jsonstudio/llms 0.6.753 → 0.6.795

package/dist/tools/exec-command/regression-capturer.js

@@ -0,0 +1,144 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createHash } from 'crypto';
+/**
+ * Captures exec_command validation regressions into a golden samples structure.
+ *
+ * Trigger: exec_command validation failure (shape/JSON/required fields)
+ *
+ * Default destination:
+ *   ~/.routecodex/golden_samples/ci-regression/exec_command/<error-type>/
+ *
+ * Optional repo destination (explicit opt-in):
+ *   ROUTECODEX_EXEC_COMMAND_REGRESSION_TO_REPO=1
+ *   → <repoRoot>/samples/ci-goldens/_regressions/exec_command/<error-type>/
+ *
+ * Explicit override:
+ *   ROUTECODEX_EXEC_COMMAND_REGRESSION_DIR=/abs/path
+ *
+ * Note: we intentionally redact obvious secrets from captured payloads.
+ */
+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_EXEC_COMMAND_REGRESSION_DIR || '').trim();
+    if (explicit) {
+        return path.resolve(explicit);
+    }
+    const toRepo = String(process?.env?.ROUTECODEX_EXEC_COMMAND_REGRESSION_TO_REPO || '').trim() === '1';
+    if (toRepo) {
+        const repoRoot = detectRepoRootFromCwd();
+        if (repoRoot) {
+            return path.join(repoRoot, 'samples', 'ci-goldens', '_regressions', 'exec_command');
+        }
+    }
+    return path.join(os.homedir(), '.routecodex', 'golden_samples', 'ci-regression', 'exec_command');
+}
+function stableSampleId(sample) {
+    const key = `${String(sample.errorType || 'unknown')}:` +
+        `${String(sample.originalArgs ?? '')}:` +
+        `${String(sample.normalizedArgs ?? '')}:` +
+        `${String(sample.validationError ?? '')}`;
+    return createHash('sha1').update(key).digest('hex').slice(0, 16);
+}
+function redactSecrets(text) {
+    if (!text)
+        return text;
+    let next = text;
+    // Common API key formats (best-effort).
+    next = next.replace(/\bsk-[A-Za-z0-9_-]{10,}\b/g, 'sk-<REDACTED>');
+    next = next.replace(/\bcr_[A-Za-z0-9]{20,}\b/g, 'cr_<REDACTED>');
+    next = next.replace(/\bAIza[0-9A-Za-z_-]{20,}\b/g, 'AIza<REDACTED>');
+    // Authorization headers.
+    next = next.replace(/(authorization\"?\s*:\s*\"?bearer\s+)[^\"]+/gi, '$1<REDACTED>');
+    next = next.replace(/(authorization:\s*bearer\s+)[^\s]+/gi, '$1<REDACTED>');
+    // Shell exports of *_KEY/*_TOKEN/*_SECRET.
+    next = next.replace(/(\bexport\s+[A-Z0-9_]*(?:KEY|TOKEN|SECRET)[A-Z0-9_]*=)[^\s'"]+/gi, '$1<REDACTED>');
+    return next;
+}
+function sanitizeArgs(raw) {
+    const trimmed = String(raw || '');
+    if (!trimmed)
+        return trimmed;
+    // If it's JSON, redact known sensitive fields (cmd) aggressively.
+    try {
+        const obj = JSON.parse(trimmed);
+        if (obj && typeof obj === 'object') {
+            const cloned = Array.isArray(obj) ? obj.slice() : { ...obj };
+            if (typeof cloned.cmd === 'string') {
+                const cmdText = String(cloned.cmd);
+                cloned.cmd = redactSecrets(cmdText).slice(0, 500);
+            }
+            return redactSecrets(JSON.stringify(cloned, null, 2));
+        }
+    }
+    catch {
+        // ignore JSON parse errors
+    }
+    return redactSecrets(trimmed);
+}
+export function captureExecCommandRegression(sample) {
+    try {
+        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 });
+        }
+        try {
+            const existing = fs.readdirSync(typeDir).filter((f) => f.endsWith('.json'));
+            if (existing.length >= MAX_SAMPLES_PER_TYPE)
+                return;
+        }
+        catch {
+            // ignore
+        }
+        const sanitized = {
+            ...sample,
+            originalArgs: sanitizeArgs(sample.originalArgs),
+            normalizedArgs: typeof sample.normalizedArgs === 'string' ? sanitizeArgs(sample.normalizedArgs) : sample.normalizedArgs
+        };
+        const id = `sample_${stableSampleId(sanitized)}`;
+        const file = path.join(typeDir, `${id}.json`);
+        if (fs.existsSync(file))
+            return;
+        const fullSample = {
+            id,
+            timestamp: new Date().toISOString(),
+            ...sanitized
+        };
+        fs.writeFileSync(file, JSON.stringify(fullSample, null, 2), 'utf-8');
+    }
+    catch {
+        // Silently fail to avoid disrupting runtime
+    }
+}

package/dist/tools/exec-command/validator.d.ts

@@ -0,0 +1,6 @@
+export type ExecCommandValidationResult = {
+    ok: boolean;
+    reason?: string;
+    normalizedArgs?: string;
+};
+export declare function validateExecCommandArgs(argsString: string, rawArgs: unknown): ExecCommandValidationResult;

package/dist/tools/exec-command/validator.js

@@ -0,0 +1,22 @@
+import { parseToolArgsJson } from '../args-json.js';
+import { normalizeExecCommandArgs } from './normalize.js';
+const isRecord = (value) => typeof value === 'object' && value !== null && !Array.isArray(value);
+const toJson = (value) => {
+    try {
+        return JSON.stringify(value ?? {});
+    }
+    catch {
+        return '{}';
+    }
+};
+export function validateExecCommandArgs(argsString, rawArgs) {
+    const raw = typeof argsString === 'string' ? argsString : String(argsString ?? '');
+    const parsed = isRecord(rawArgs) && Object.keys(rawArgs).length > 0
+        ? rawArgs
+        : parseToolArgsJson(raw);
+    const normalized = normalizeExecCommandArgs(parsed);
+    if (normalized.ok === false) {
+        return { ok: false, reason: normalized.reason };
+    }
+    return { ok: true, normalizedArgs: toJson(normalized.normalized) };
+}

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

@@ -0,0 +1,15 @@
+export interface PatchNormalizationResult {
+    normalized?: string;
+    error?: string;
+}
+/**
+ * Attempt to fix common apply_patch argument format issues:
+ * 1. Missing *** Begin Patch / *** End Patch markers
+ * 2. Lines missing +/- prefix in hunks
+ * 3. Field aliases (input->patch, code->patch, diff->patch)
+ * 4. Structured changes array conversion
+ * 5. Git diff format conversion
+ */
+export declare function normalizeApplyPatchArgs(argsStr: string): PatchNormalizationResult;
+export declare function looksLikePatch(text?: string): boolean;
+export declare function normalizeApplyPatchText(raw: string): string;

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

@@ -0,0 +1,472 @@
+// Unified apply_patch arguments normalizer
+// Centralizes all fixable format repairs: missing headers, prefix issues, field aliases, etc.
+// Does NOT fix context mismatches (those must be reported to user).
+import { buildStructuredPatch, isStructuredApplyPatchPayload } from './apply-patch-structured.js';
+/**
+ * Attempt to fix common apply_patch argument format issues:
+ * 1. Missing *** Begin Patch / *** End Patch markers
+ * 2. Lines missing +/- prefix in hunks
+ * 3. Field aliases (input->patch, code->patch, diff->patch)
+ * 4. Structured changes array conversion
+ * 5. Git diff format conversion
+ */
+export function normalizeApplyPatchArgs(argsStr) {
+    try {
+        let args;
+        try {
+            args = JSON.parse(argsStr);
+        }
+        catch {
+            // Fallback: raw patch text without JSON wrapper
+            if (argsStr.includes('*** Begin Patch')) {
+                return { normalized: JSON.stringify({ patch: argsStr }) };
+            }
+            return { error: 'invalid_json' };
+        }
+        if (!args || typeof args !== 'object') {
+            return { error: 'invalid_args_type' };
+        }
+        let modified = false;
+        // Fix 1: Handle field aliases
+        if (args.patch && args.input) {
+            delete args.input;
+            modified = true;
+        }
+        else if (!args.patch && args.input) {
+            args.patch = args.input;
+            delete args.input;
+            modified = true;
+        }
+        // Fix 2: Convert structured changes to patch text
+        if (!args.patch && isStructuredApplyPatchPayload(args)) {
+            try {
+                args.patch = buildStructuredPatch(args);
+                delete args.changes;
+                delete args.file;
+                delete args.instructions;
+                modified = true;
+            }
+            catch {
+                // Let structured errors pass through
+            }
+        }
+        // Fix 2.1: Convert { changes:[{search,replace}] } to structured replace
+        if (!args.patch && Array.isArray(args.changes)) {
+            const converted = convertSearchReplaceChanges(args);
+            if (converted) {
+                try {
+                    args.patch = buildStructuredPatch(converted);
+                    delete args.changes;
+                    delete args.file;
+                    delete args.instructions;
+                    modified = true;
+                }
+                catch {
+                    // Ignore conversion failure
+                }
+            }
+        }
+        // Fix 3: Alias fields (code, diff) -> patch
+        if (!args.patch) {
+            if (typeof args.code === 'string') {
+                args.patch = args.code;
+                delete args.code;
+                modified = true;
+            }
+            else if (typeof args.diff === 'string') {
+                args.patch = args.diff;
+                delete args.diff;
+                modified = true;
+            }
+        }
+        // Fix 4: Normalize patch text format
+        if (typeof args.patch === 'string') {
+            const cleaned = stripConflictMarkers(args.patch);
+            if (cleaned !== args.patch) {
+                args.patch = cleaned;
+                modified = true;
+            }
+            const fixed = fixPatchTextFormat(args.patch);
+            if (fixed !== args.patch) {
+                args.patch = fixed;
+                modified = true;
+            }
+        }
+        return modified ? { normalized: JSON.stringify(args) } : { normalized: null };
+    }
+    catch (error) {
+        return { error: 'normalization_failed' };
+    }
+}
+export function looksLikePatch(text) {
+    if (!text)
+        return false;
+    const t = text.trim();
+    if (!t)
+        return false;
+    return (t.includes('*** Begin Patch') ||
+        t.includes('*** Update File:') ||
+        t.includes('*** Add File:') ||
+        t.includes('*** Delete File:') ||
+        t.includes('diff --git') ||
+        /^(?:@@|\+\+\+\s|---\s)/m.test(t));
+}
+export function normalizeApplyPatchText(raw) {
+    if (!raw)
+        return raw;
+    let text = raw.replace(/\r\n/g, '\n');
+    text = decodeEscapedNewlinesIfNeeded(text);
+    text = stripCodeFences(text);
+    text = text.trim();
+    if (!text) {
+        return raw;
+    }
+    if (!text.includes('*** Begin Patch') && text.includes('diff --git')) {
+        const converted = convertGitDiffToApplyPatch(text);
+        if (converted) {
+            text = converted;
+        }
+    }
+    else if (!text.includes('*** Begin Patch') && !text.includes('diff --git')) {
+        const minusMatch = text.match(/^---\s+(.*)$/m);
+        const plusMatch = text.match(/^\+\+\+\s+(.*)$/m);
+        if (minusMatch && plusMatch) {
+            const rawPlus = plusMatch[1] || '';
+            const pathMatch = rawPlus.match(/^(?:b\/)?(.+)$/);
+            const path = (pathMatch && pathMatch[1] ? pathMatch[1] : rawPlus).trim();
+            if (path) {
+                const synthetic = `diff --git a/${path} b/${path}\n${text}`;
+                const converted = convertGitDiffToApplyPatch(synthetic);
+                if (converted) {
+                    text = converted;
+                }
+            }
+        }
+    }
+    if (text.includes('*** Add File:')) {
+        text = text.replace(/\*\*\* Create File:/g, '*** Add File:');
+    }
+    let hasBegin = text.includes('*** Begin Patch');
+    const hasEnd = text.includes('*** End Patch');
+    if (hasBegin && !hasEnd) {
+        text = `${text}\n*** End Patch`;
+    }
+    if (!hasBegin && /^\*\*\* (Add|Update|Delete) File:/m.test(text)) {
+        text = `*** Begin Patch\n${text}\n*** End Patch`;
+        hasBegin = true;
+    }
+    if (!text.includes('*** Begin Patch')) {
+        return text;
+    }
+    const beginIndex = text.indexOf('*** Begin Patch');
+    if (beginIndex > 0) {
+        text = text.slice(beginIndex);
+    }
+    const endMarker = '*** End Patch';
+    const firstEndIndex = text.indexOf(endMarker);
+    const concatSignatures = [
+        `${endMarker}","input":"*** Begin Patch`,
+        `${endMarker}","patch":"*** Begin Patch`,
+        `${endMarker}\\",\\"input\\":\\"*** Begin Patch`,
+        `${endMarker}\\",\\"patch\\":\\"*** Begin Patch`
+    ];
+    const hasConcatenationSignal = concatSignatures.some((sig) => text.includes(sig));
+    if (hasConcatenationSignal && firstEndIndex >= 0) {
+        text = text.slice(0, firstEndIndex + endMarker.length);
+    }
+    else {
+        const lastEndIndex = text.lastIndexOf(endMarker);
+        if (lastEndIndex >= 0) {
+            const afterEnd = text.slice(lastEndIndex + endMarker.length);
+            if (afterEnd.trim().length > 0) {
+                text = text.slice(0, lastEndIndex + endMarker.length);
+            }
+        }
+    }
+    const lines = text.split('\n');
+    const output = [];
+    let inUpdateSection = false;
+    let afterUpdateHeader = false;
+    for (const line of lines) {
+        if (line.startsWith('*** Begin Patch')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** End Patch')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** Update File:')) {
+            output.push(line);
+            inUpdateSection = true;
+            afterUpdateHeader = true;
+            continue;
+        }
+        if (line.startsWith('*** Add File:') || line.startsWith('*** Delete File:')) {
+            output.push(line);
+            inUpdateSection = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (inUpdateSection) {
+            if (afterUpdateHeader && line.trim() === '') {
+                continue;
+            }
+            afterUpdateHeader = false;
+            if (line.startsWith('@@') || line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+                output.push(line);
+            }
+            else {
+                output.push(` ${line}`);
+            }
+            continue;
+        }
+        output.push(line);
+    }
+    return output.join('\n');
+}
+/**
+ * Fix common patch text format issues:
+ * - Missing *** Begin/End Patch markers
+ * - Lines missing +/- prefix in update hunks
+ * - Extra whitespace/comments
+ */
+function fixPatchTextFormat(patchText) {
+    let text = patchText.trim();
+    if (!text)
+        return patchText;
+    // Fix 1: Add missing *** Begin Patch
+    const hasBegin = text.includes('*** Begin Patch');
+    const hasEnd = text.includes('*** End Patch');
+    const hasFileOp = /^\*\*\* (Add|Update|Delete) File:/m.test(text);
+    if (!hasBegin && hasFileOp) {
+        text = `*** Begin Patch\n${text}`;
+    }
+    // Fix 2: Add missing *** End Patch
+    if (text.includes('*** Begin Patch') && !hasEnd) {
+        text = `${text}\n*** End Patch`;
+    }
+    // Fix 3: Normalize lines in update hunks
+    text = fixHunkLinePrefixes(text);
+    return text;
+}
+/**
+ * Fix missing +/- prefixes in update hunks.
+ * Pattern: After "*** Update File:" and before next file operation,
+ * lines should start with ' ', '+', '-', or '@@'.
+ */
+function fixHunkLinePrefixes(text) {
+    const lines = text.split('\n');
+    const output = [];
+    let inUpdateHunk = false;
+    let afterUpdateHeader = false;
+    for (const line of lines) {
+        // Track section boundaries
+        if (line.startsWith('*** Begin Patch') || line.startsWith('*** End Patch')) {
+            output.push(line);
+            inUpdateHunk = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (line.startsWith('*** Update File:')) {
+            output.push(line);
+            inUpdateHunk = true;
+            afterUpdateHeader = true;
+            continue;
+        }
+        if (line.startsWith('*** Add File:') || line.startsWith('*** Delete File:')) {
+            output.push(line);
+            inUpdateHunk = false;
+            afterUpdateHeader = false;
+            continue;
+        }
+        // Skip empty line after Update File: header
+        if (inUpdateHunk && afterUpdateHeader && line.trim() === '') {
+            afterUpdateHeader = false;
+            continue;
+        }
+        if (inUpdateHunk) {
+            afterUpdateHeader = false;
+            // Line should start with ' ', '+', '-', or '@@'
+            if (line.startsWith('@@') || line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+                output.push(line);
+            }
+            else if (line.trim() === '') {
+                // Empty lines in hunks become context lines
+                output.push(' ');
+            }
+            else {
+                // Missing prefix: treat as context line
+                output.push(` ${line}`);
+            }
+            continue;
+        }
+        // Not in update hunk: pass through
+        output.push(line);
+    }
+    return output.join('\n');
+}
+function stripConflictMarkers(patchText) {
+    if (!patchText.includes('<<<<<<<') && !patchText.includes('>>>>>>>') && !patchText.includes('=======')) {
+        return patchText;
+    }
+    const lines = patchText.split('\n');
+    const cleanLines = [];
+    for (const line of lines) {
+        if (line.startsWith('<<<<<<<')) {
+            if (line.includes('SEARCH')) {
+                cleanLines.push(line);
+            }
+            continue;
+        }
+        if (line.startsWith('=======')) {
+            cleanLines.push(line);
+            continue;
+        }
+        if (line.startsWith('>>>>>>>')) {
+            if (line.includes('REPLACE')) {
+                cleanLines.push(line);
+            }
+            continue;
+        }
+        cleanLines.push(line);
+    }
+    return cleanLines.join('\n');
+}
+function convertSearchReplaceChanges(payload) {
+    if (!payload || !Array.isArray(payload.changes))
+        return null;
+    const outChanges = [];
+    let saw = false;
+    for (const entry of payload.changes) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        if (typeof entry.search === 'string' && typeof entry.replace === 'string') {
+            outChanges.push({
+                kind: 'replace',
+                file: typeof entry.file === 'string' ? entry.file : payload.file,
+                target: entry.search,
+                lines: entry.replace
+            });
+            saw = true;
+        }
+    }
+    if (!saw)
+        return null;
+    return { file: payload.file, changes: outChanges };
+}
+function decodeEscapedNewlinesIfNeeded(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;
+}
+function stripCodeFences(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith('```')) {
+        return text;
+    }
+    const fenceRe = /^```(?:diff|patch|apply_patch|text|json)?[ \t]*\n([\s\S]*?)\n```/gmi;
+    const candidates = [];
+    let match = null;
+    while ((match = fenceRe.exec(trimmed))) {
+        if (match[1]) {
+            candidates.push(match[1].trim());
+        }
+    }
+    if (!candidates.length) {
+        return text;
+    }
+    for (const candidate of candidates) {
+        if (candidate.includes('*** Begin Patch') ||
+            candidate.includes('*** Update File:') ||
+            candidate.includes('diff --git')) {
+            return candidate;
+        }
+    }
+    return candidates[0] ?? text;
+}
+function convertGitDiffToApplyPatch(text) {
+    const lines = text.replace(/\r\n/g, '\n').split('\n');
+    const files = [];
+    let current = null;
+    const flush = () => {
+        if (!current)
+            return;
+        if (current.path && current.kind === 'delete') {
+            files.push(current);
+            current = null;
+            return;
+        }
+        if (!current.path || (current.kind === 'update' && current.lines.length === 0)) {
+            current = null;
+            return;
+        }
+        files.push(current);
+        current = null;
+    };
+    for (const raw of lines) {
+        const line = raw;
+        const diffMatch = line.match(/^diff --git a\/(.+?) b\/(.+)$/);
+        if (diffMatch) {
+            flush();
+            const path = diffMatch[2] || diffMatch[1];
+            current = { path, kind: 'update', lines: [] };
+            continue;
+        }
+        if (!current)
+            continue;
+        if (line.startsWith('new file mode')) {
+            current.kind = 'add';
+            continue;
+        }
+        if (line.startsWith('deleted file mode')) {
+            current.kind = 'delete';
+            continue;
+        }
+        if (line.startsWith('@@') || line.startsWith('+') || line.startsWith('-') || line.startsWith(' ')) {
+            current.lines.push(line);
+            continue;
+        }
+    }
+    flush();
+    if (!files.length)
+        return null;
+    const out = ['*** Begin Patch'];
+    for (const file of files) {
+        if (file.kind === 'add') {
+            out.push(`*** Add File: ${file.path}`);
+            for (const line of file.lines) {
+                out.push(line.startsWith('+') ? line : `+${line}`);
+            }
+        }
+        else if (file.kind === 'delete') {
+            out.push(`*** Delete File: ${file.path}`);
+        }
+        else {
+            out.push(`*** Update File: ${file.path}`);
+            out.push(...file.lines);
+        }
+    }
+    out.push('*** End Patch');
+    return out.join('\n');
+}

package/dist/tools/patch-regression-capturer.d.ts

@@ -0,0 +1 @@
+export { captureApplyPatchRegression } from './apply-patch/regression-capturer.js';

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

@@ -0,0 +1 @@
+export { captureApplyPatchRegression } from './apply-patch/regression-capturer.js';