@jsonstudio/rcc 0.90.364 → 0.90.429

package/vendor/@jsonstudio/llms/dist/tools/apply-patch/args-normalizer/extract-patch.js

@@ -1,15 +0,0 @@
-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);
-    if (!patchLike) {
-        return {};
-    }
-    if (!/^(?:\s*)\*\*\*\s*Begin Patch\b/m.test(normalized)) {
-        return { failureReason: 'unsupported_patch_format' };
-    }
-    return { patchText: normalized };
-}

package/vendor/@jsonstudio/llms/dist/tools/apply-patch/args-normalizer/index.d.ts

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

package/vendor/@jsonstudio/llms/dist/tools/apply-patch/args-normalizer/index.js

@@ -1,164 +0,0 @@
-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/vendor/@jsonstudio/llms/dist/tools/apply-patch/args-normalizer/structured-builders.d.ts

@@ -1,7 +0,0 @@
-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/vendor/@jsonstudio/llms/dist/tools/apply-patch/args-normalizer/structured-builders.js

@@ -1,85 +0,0 @@
-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/vendor/@jsonstudio/llms/dist/tools/apply-patch/args-normalizer/types.d.ts

@@ -1,54 +0,0 @@
-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/vendor/@jsonstudio/llms/dist/tools/apply-patch/args-normalizer/types.js

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

package/vendor/@jsonstudio/llms/dist/tools/apply-patch/execution-capturer.d.ts

@@ -1,13 +0,0 @@
-export interface ApplyPatchExecutionFailureCaptureContext {
-    requestId?: string;
-    entryEndpoint?: string;
-    providerKey?: string;
-    model?: string;
-    source?: string;
-    meta?: Record<string, unknown>;
-}
-export declare function captureApplyPatchExecutionFailure(content: string, context: ApplyPatchExecutionFailureCaptureContext & {
-    toolCallId?: string;
-    toolCallArgs?: string;
-}): void;
-export declare function captureApplyPatchExecutionFailuresFromProcessedRequest(processedRequest: unknown): void;

package/vendor/@jsonstudio/llms/dist/tools/apply-patch/execution-capturer.js

@@ -1,181 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { createHash } from 'crypto';
-/**
- * Captures apply_patch execution failures (tool role message contents) into errorsamples.
- *
- * IMPORTANT (RouteCodex policy):
- * - Only keep apply_patch "shape" failures in errorsamples.
- * - Context/execution failures (file missing, context mismatch, expected lines mismatch)
- *   are noisy and not actionable, so they are NOT captured by default.
- *
- * Explicit opt-in for debugging:
- *   ROUTECODEX_ERRORSAMPLES_APPLY_PATCH_EXEC=1
- *
- * Default destination:
- *   ~/.routecodex/errorsamples/apply_patch_exec/<error-type>/
- *
- * Explicit override:
- *   ROUTECODEX_APPLY_PATCH_EXEC_DIR=/abs/path
- *
- * Note: if ROUTECODEX_ERRORSAMPLES_DIR is set, it is used as the base root.
- */
-const MAX_SAMPLES_PER_TYPE = 250;
-const EXEC_ERRORSAMPLES_ENABLED = String(process?.env?.ROUTECODEX_ERRORSAMPLES_APPLY_PATCH_EXEC || '').trim() === '1';
-function resolveSamplesRoot() {
-    const explicit = String(process?.env?.ROUTECODEX_APPLY_PATCH_EXEC_DIR || '').trim();
-    if (explicit)
-        return path.resolve(explicit);
-    const base = String(process?.env?.ROUTECODEX_ERRORSAMPLES_DIR || '').trim();
-    if (base)
-        return path.join(path.resolve(base), 'apply_patch_exec');
-    return path.join(os.homedir(), '.routecodex', 'errorsamples', 'apply_patch_exec');
-}
-function classifyExecutionFailure(content) {
-    const raw = String(content || '');
-    const trimmed = raw.trim();
-    const prefix = 'apply_patch verification failed:';
-    const msg = trimmed.toLowerCase().startsWith(prefix) ? trimmed.slice(prefix.length).trim() : trimmed;
-    const lower = msg.toLowerCase();
-    if (lower.includes('failed to read file'))
-        return { errorType: 'read_file_failed', message: msg };
-    if (lower.includes('no such file') || lower.includes('file not found'))
-        return { errorType: 'file_not_found', message: msg };
-    if (lower.includes('failed to find context'))
-        return { errorType: 'context_not_found', message: msg };
-    if (lower.includes('failed to find expected lines'))
-        return { errorType: 'expected_lines_not_found', message: msg };
-    if (lower.includes('invalid patch'))
-        return { errorType: 'invalid_patch', message: msg };
-    if (lower.includes('failed to parse'))
-        return { errorType: 'parse_failed', message: msg };
-    return { errorType: 'unknown', message: msg };
-}
-function isContextExecutionFailureType(errorType) {
-    const t = String(errorType || '').trim().toLowerCase();
-    return (t === 'read_file_failed' ||
-        t === 'file_not_found' ||
-        t === 'context_not_found' ||
-        t === 'expected_lines_not_found');
-}
-function stableSampleId(fields) {
-    const key = `${String(fields.errorType || 'unknown')}:${String(fields.errorMessage || '')}:` +
-        `${String(fields.toolCallId || '')}:${String(fields.toolCallArgs || '')}:${String(fields.requestId || '')}:${String(fields.mode || '')}`;
-    return createHash('sha1').update(key).digest('hex').slice(0, 16);
-}
-export function captureApplyPatchExecutionFailure(content, context) {
-    try {
-        if (!EXEC_ERRORSAMPLES_ENABLED)
-            return;
-        const { errorType, message } = classifyExecutionFailure(content);
-        // Keep only non-context types (i.e. parse/format issues). Context mismatches are not captured.
-        if (isContextExecutionFailureType(errorType))
-            return;
-        if (String(errorType || '').trim().toLowerCase() === 'unknown')
-            return;
-        const root = resolveSamplesRoot();
-        const safeType = String(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 mode = String(context.meta?.applyPatchToolMode || '').trim();
-        const id = `sample_${stableSampleId({
-            errorType,
-            errorMessage: message,
-            toolCallId: context.toolCallId,
-            toolCallArgs: context.toolCallArgs,
-            requestId: context.requestId,
-            mode
-        })}`;
-        const file = path.join(typeDir, `${id}.json`);
-        if (fs.existsSync(file))
-            return;
-        const sample = {
-            id,
-            timestamp: new Date().toISOString(),
-            errorType,
-            errorMessage: message,
-            toolCallId: context.toolCallId,
-            toolCallArgs: context.toolCallArgs,
-            requestId: context.requestId,
-            entryEndpoint: context.entryEndpoint,
-            providerKey: context.providerKey,
-            model: context.model,
-            source: context.source,
-            meta: context.meta
-        };
-        fs.writeFileSync(file, JSON.stringify(sample, null, 2), 'utf-8');
-    }
-    catch {
-        // Silently fail to avoid disrupting runtime
-    }
-}
-export function captureApplyPatchExecutionFailuresFromProcessedRequest(processedRequest) {
-    try {
-        if (!EXEC_ERRORSAMPLES_ENABLED)
-            return;
-        const anyReq = processedRequest;
-        const messages = Array.isArray(anyReq?.messages) ? anyReq.messages : [];
-        if (!messages.length)
-            return;
-        const metadata = anyReq?.metadata || {};
-        const requestId = typeof metadata?.requestId === 'string' ? metadata.requestId : undefined;
-        const entryEndpoint = typeof metadata?.originalEndpoint === 'string' ? metadata.originalEndpoint : undefined;
-        const providerKey = typeof metadata?.providerKey === 'string' ? metadata.providerKey : undefined;
-        const model = typeof anyReq?.model === 'string' ? anyReq.model : undefined;
-        const applyPatchToolMode = typeof metadata?.applyPatchToolMode === 'string' ? String(metadata.applyPatchToolMode).trim().toLowerCase() : '';
-        const resolvedMode = applyPatchToolMode === 'schema' ? 'schema' : 'freeform';
-        const toolCallArgsById = new Map();
-        for (const msg of messages) {
-            if (!msg || typeof msg !== 'object')
-                continue;
-            const toolCalls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
-            for (const tc of toolCalls) {
-                const id = typeof tc?.id === 'string' ? String(tc.id) : '';
-                const fn = tc?.function;
-                const name = typeof fn?.name === 'string' ? String(fn.name).trim().toLowerCase() : '';
-                if (!id || name !== 'apply_patch')
-                    continue;
-                const args = typeof fn?.arguments === 'string' ? String(fn.arguments) : '';
-                if (args)
-                    toolCallArgsById.set(id, args);
-            }
-        }
-        for (const msg of messages) {
-            if (!msg || typeof msg !== 'object')
-                continue;
-            const role = msg.role;
-            const name = typeof msg.name === 'string' ? String(msg.name).trim().toLowerCase() : '';
-            const content = typeof msg.content === 'string' ? String(msg.content) : '';
-            if (role !== 'tool' || name !== 'apply_patch')
-                continue;
-            if (!content.toLowerCase().includes('apply_patch verification failed'))
-                continue;
-            const toolCallId = typeof msg.tool_call_id === 'string' ? String(msg.tool_call_id) : undefined;
-            const toolCallArgs = toolCallId ? toolCallArgsById.get(toolCallId) : undefined;
-            captureApplyPatchExecutionFailure(content, {
-                requestId,
-                entryEndpoint,
-                providerKey,
-                model,
-                source: 'chat_process.req.stage4.tool_governance',
-                meta: { applyPatchToolMode: resolvedMode },
-                toolCallId,
-                toolCallArgs
-            });
-        }
-    }
-    catch {
-        // ignore
-    }
-}

package/vendor/@jsonstudio/llms/dist/tools/apply-patch/json/parse-loose.d.ts

@@ -1,3 +0,0 @@
-declare const tryParseJson: (value: unknown) => unknown;
-declare const tryParseJsonLoose: (value: unknown) => unknown;
-export { tryParseJson, tryParseJsonLoose };

package/vendor/@jsonstudio/llms/dist/tools/apply-patch/json/parse-loose.js

@@ -1,139 +0,0 @@
-const tryParseJson = (value) => {
-    if (typeof value !== 'string')
-        return undefined;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
-        return undefined;
-    try {
-        return JSON.parse(trimmed);
-    }
-    catch {
-        return undefined;
-    }
-};
-const escapeUnescapedQuotesInJsonStrings = (input) => {
-    // Best-effort: when JSON is almost valid but contains unescaped `"` inside string values
-    // (e.g. JSX snippets like className="..."), escape quotes that are not followed by a
-    // valid JSON token delimiter. Deterministic; does not attempt to fix structural issues.
-    let out = '';
-    let inString = false;
-    let escaped = false;
-    for (let i = 0; i < input.length; i += 1) {
-        const ch = input[i] ?? '';
-        if (!inString) {
-            if (ch === '"') {
-                inString = true;
-                escaped = false;
-            }
-            out += ch;
-            continue;
-        }
-        if (escaped) {
-            out += ch;
-            escaped = false;
-            continue;
-        }
-        if (ch === '\\') {
-            out += ch;
-            escaped = true;
-            continue;
-        }
-        if (ch === '"') {
-            let j = i + 1;
-            while (j < input.length && /\s/.test(input[j] ?? ''))
-                j += 1;
-            const next = j < input.length ? input[j] : '';
-            if (next === '' || next === ':' || next === ',' || next === '}' || next === ']') {
-                inString = false;
-                out += ch;
-            }
-            else {
-                out += '\\"';
-            }
-            continue;
-        }
-        out += ch;
-    }
-    return out;
-};
-const balanceJsonContainers = (input) => {
-    // Best-effort bracket/brace balancing for JSON-like strings.
-    // Only operates outside string literals. When encountering a closing token that doesn't
-    // match the current stack top, inserts the missing closer(s) to recover.
-    let out = '';
-    let inString = false;
-    let escaped = false;
-    const stack = [];
-    const closeFor = (open) => (open === '{' ? '}' : ']');
-    for (let i = 0; i < input.length; i += 1) {
-        const ch = input[i] ?? '';
-        if (inString) {
-            out += ch;
-            if (escaped) {
-                escaped = false;
-                continue;
-            }
-            if (ch === '\\') {
-                escaped = true;
-                continue;
-            }
-            if (ch === '"') {
-                inString = false;
-            }
-            continue;
-        }
-        if (ch === '"') {
-            inString = true;
-            out += ch;
-            continue;
-        }
-        if (ch === '{' || ch === '[') {
-            stack.push(ch);
-            out += ch;
-            continue;
-        }
-        if (ch === '}' || ch === ']') {
-            const expectedOpen = ch === '}' ? '{' : '[';
-            while (stack.length && stack[stack.length - 1] !== expectedOpen) {
-                const open = stack.pop();
-                out += closeFor(open);
-            }
-            if (stack.length && stack[stack.length - 1] === expectedOpen) {
-                stack.pop();
-            }
-            out += ch;
-            continue;
-        }
-        out += ch;
-    }
-    while (stack.length) {
-        const open = stack.pop();
-        out += closeFor(open);
-    }
-    return out;
-};
-const tryParseJsonLoose = (value) => {
-    const parsed = tryParseJson(value);
-    if (parsed !== undefined)
-        return parsed;
-    if (typeof value !== 'string')
-        return undefined;
-    const trimmed = value.trim();
-    if (!trimmed)
-        return undefined;
-    if (!(trimmed.startsWith('{') || trimmed.startsWith('[')))
-        return undefined;
-    let repaired = escapeUnescapedQuotesInJsonStrings(trimmed);
-    repaired = balanceJsonContainers(repaired);
-    if (!repaired || repaired === trimmed)
-        return undefined;
-    try {
-        return JSON.parse(repaired);
-    }
-    catch {
-        return undefined;
-    }
-};
-export { tryParseJson, tryParseJsonLoose };

package/vendor/@jsonstudio/llms/dist/tools/apply-patch/patch-text/context-diff.d.ts

@@ -1 +0,0 @@
-export declare const convertContextDiffToApplyPatch: (text: string) => string | null;