agentic-qe 3.15.1 → 3.15.3

package/dist/adapters/ag-ui/json-patch-utils.js

@@ -1,575 +0,0 @@
-/**
- * JSON Patch Utilities (RFC 6902)
- *
- * Provides utilities for computing and applying JSON Patch operations
- * for AG-UI STATE_DELTA event synchronization.
- *
- * Reference: https://datatracker.ietf.org/doc/html/rfc6902
- *
- * @module adapters/ag-ui/json-patch-utils
- */
-import { toErrorMessage } from '../../shared/error-utils.js';
-// ============================================================================
-// Path Utilities
-// ============================================================================
-/**
- * Escape special characters in a JSON Pointer token (RFC 6901)
- * ~ becomes ~0
- * / becomes ~1
- */
-export function escapePathToken(token) {
-    return token.replace(/~/g, '~0').replace(/\//g, '~1');
-}
-/**
- * Unescape special characters in a JSON Pointer token (RFC 6901)
- * ~0 becomes ~
- * ~1 becomes /
- */
-export function unescapePathToken(token) {
-    return token.replace(/~1/g, '/').replace(/~0/g, '~');
-}
-/**
- * Parse a JSON Pointer path into tokens
- */
-export function parsePath(path) {
-    if (path === '') {
-        return [];
-    }
-    if (!path.startsWith('/')) {
-        throw new Error(`Invalid JSON Pointer: path must start with '/' or be empty, got '${path}'`);
-    }
-    return path.slice(1).split('/').map(unescapePathToken);
-}
-/**
- * Build a JSON Pointer path from tokens
- */
-export function buildPath(tokens) {
-    if (tokens.length === 0) {
-        return '';
-    }
-    return '/' + tokens.map(escapePathToken).join('/');
-}
-/**
- * Get a value from an object using a JSON Pointer path
- */
-export function getValueAtPath(document, path) {
-    if (path === '') {
-        return document;
-    }
-    const tokens = parsePath(path);
-    let current = document;
-    for (const token of tokens) {
-        if (current === null || current === undefined) {
-            return undefined;
-        }
-        if (Array.isArray(current)) {
-            const index = token === '-' ? current.length : parseInt(token, 10);
-            if (isNaN(index) || index < 0) {
-                return undefined;
-            }
-            current = current[index];
-        }
-        else if (typeof current === 'object') {
-            current = current[token];
-        }
-        else {
-            return undefined;
-        }
-    }
-    return current;
-}
-/**
- * Set a value at a JSON Pointer path (mutates the document)
- */
-export function setValueAtPath(document, path, value) {
-    if (path === '') {
-        throw new Error('Cannot replace root document');
-    }
-    const tokens = parsePath(path);
-    const lastToken = tokens.pop();
-    let current = document;
-    for (const token of tokens) {
-        if (current === null || current === undefined) {
-            throw new Error(`Path does not exist: ${path}`);
-        }
-        if (Array.isArray(current)) {
-            const index = parseInt(token, 10);
-            if (isNaN(index) || index < 0 || index >= current.length) {
-                throw new Error(`Invalid array index: ${token}`);
-            }
-            current = current[index];
-        }
-        else if (typeof current === 'object') {
-            if (!(token in current)) {
-                throw new Error(`Path does not exist: ${path}`);
-            }
-            current = current[token];
-        }
-        else {
-            throw new Error(`Cannot traverse non-object: ${path}`);
-        }
-    }
-    if (Array.isArray(current)) {
-        const index = lastToken === '-' ? current.length : parseInt(lastToken, 10);
-        if (isNaN(index) || index < 0) {
-            throw new Error(`Invalid array index: ${lastToken}`);
-        }
-        current[index] = value;
-    }
-    else if (typeof current === 'object' && current !== null) {
-        current[lastToken] = value;
-    }
-    else {
-        throw new Error(`Cannot set value at path: ${path}`);
-    }
-}
-/**
- * Delete a value at a JSON Pointer path (mutates the document)
- */
-export function deleteValueAtPath(document, path) {
-    if (path === '') {
-        throw new Error('Cannot remove root document');
-    }
-    const tokens = parsePath(path);
-    const lastToken = tokens.pop();
-    let current = document;
-    for (const token of tokens) {
-        if (current === null || current === undefined) {
-            throw new Error(`Path does not exist: ${path}`);
-        }
-        if (Array.isArray(current)) {
-            const index = parseInt(token, 10);
-            if (isNaN(index) || index < 0 || index >= current.length) {
-                throw new Error(`Invalid array index: ${token}`);
-            }
-            current = current[index];
-        }
-        else if (typeof current === 'object') {
-            current = current[token];
-        }
-        else {
-            throw new Error(`Cannot traverse non-object: ${path}`);
-        }
-    }
-    if (Array.isArray(current)) {
-        const index = parseInt(lastToken, 10);
-        if (isNaN(index) || index < 0 || index >= current.length) {
-            throw new Error(`Invalid array index: ${lastToken}`);
-        }
-        current.splice(index, 1);
-    }
-    else if (typeof current === 'object' && current !== null) {
-        if (!(lastToken in current)) {
-            throw new Error(`Path does not exist: ${path}`);
-        }
-        delete current[lastToken];
-    }
-    else {
-        throw new Error(`Cannot delete value at path: ${path}`);
-    }
-}
-/**
- * Check if a path exists in the document
- */
-export function pathExists(document, path) {
-    if (path === '') {
-        return true;
-    }
-    const tokens = parsePath(path);
-    let current = document;
-    for (const token of tokens) {
-        if (current === null || current === undefined) {
-            return false;
-        }
-        if (Array.isArray(current)) {
-            const index = parseInt(token, 10);
-            if (isNaN(index) || index < 0 || index >= current.length) {
-                return false;
-            }
-            current = current[index];
-        }
-        else if (typeof current === 'object') {
-            if (!(token in current)) {
-                return false;
-            }
-            current = current[token];
-        }
-        else {
-            return false;
-        }
-    }
-    return true;
-}
-// ============================================================================
-// Validation
-// ============================================================================
-/**
- * Validate a single patch operation
- */
-export function validateOperation(op) {
-    // Check operation type
-    const validOps = ['add', 'remove', 'replace', 'move', 'copy', 'test'];
-    if (!validOps.includes(op.op)) {
-        return { valid: false, error: `Invalid operation: ${op.op}` };
-    }
-    // Check path
-    if (typeof op.path !== 'string') {
-        return { valid: false, error: 'Path must be a string' };
-    }
-    if (op.path !== '' && !op.path.startsWith('/')) {
-        return { valid: false, error: 'Path must start with / or be empty' };
-    }
-    // Check value for operations that require it
-    if (['add', 'replace', 'test'].includes(op.op) && !('value' in op)) {
-        return { valid: false, error: `Operation '${op.op}' requires a value` };
-    }
-    // Check from for move/copy operations
-    if (['move', 'copy'].includes(op.op)) {
-        if (!('from' in op) || typeof op.from !== 'string') {
-            return { valid: false, error: `Operation '${op.op}' requires 'from' path` };
-        }
-        if (op.from !== '' && !op.from.startsWith('/')) {
-            return { valid: false, error: "'from' path must start with / or be empty" };
-        }
-    }
-    return { valid: true };
-}
-/**
- * Validate an array of patch operations
- */
-export function validatePatch(patch) {
-    for (let i = 0; i < patch.length; i++) {
-        const result = validateOperation(patch[i]);
-        if (!result.valid) {
-            return { valid: false, error: `Operation ${i}: ${result.error}` };
-        }
-    }
-    return { valid: true };
-}
-// ============================================================================
-// Patch Application
-// ============================================================================
-/**
- * Apply a single patch operation to a document
- * Returns a new document (immutable)
- */
-export function applyOperation(document, op) {
-    // Deep clone to avoid mutation
-    const result = structuredClone(document);
-    switch (op.op) {
-        case 'add': {
-            if (op.path === '') {
-                // Replace entire document
-                if (typeof op.value !== 'object' || op.value === null) {
-                    throw new Error('Cannot replace root with non-object');
-                }
-                return structuredClone(op.value);
-            }
-            addValue(result, op.path, op.value);
-            break;
-        }
-        case 'remove': {
-            deleteValueAtPath(result, op.path);
-            break;
-        }
-        case 'replace': {
-            if (!pathExists(result, op.path)) {
-                throw new Error(`Path does not exist for replace: ${op.path}`);
-            }
-            setValueAtPath(result, op.path, structuredClone(op.value));
-            break;
-        }
-        case 'move': {
-            const from = op.from;
-            const value = getValueAtPath(result, from);
-            if (value === undefined && !pathExists(result, from)) {
-                throw new Error(`Source path does not exist for move: ${from}`);
-            }
-            deleteValueAtPath(result, from);
-            addValue(result, op.path, structuredClone(value));
-            break;
-        }
-        case 'copy': {
-            const from = op.from;
-            const value = getValueAtPath(result, from);
-            if (value === undefined && !pathExists(result, from)) {
-                throw new Error(`Source path does not exist for copy: ${from}`);
-            }
-            addValue(result, op.path, structuredClone(value));
-            break;
-        }
-        case 'test': {
-            const currentValue = getValueAtPath(result, op.path);
-            if (!deepEqual(currentValue, op.value)) {
-                throw new Error(`Test failed at path ${op.path}: expected ${JSON.stringify(op.value)}, got ${JSON.stringify(currentValue)}`);
-            }
-            break;
-        }
-        default:
-            throw new Error(`Unknown operation: ${op.op}`);
-    }
-    return result;
-}
-/**
- * Add a value at a path (handles array insertion)
- */
-function addValue(document, path, value) {
-    const tokens = parsePath(path);
-    const lastToken = tokens.pop();
-    let current = document;
-    // Navigate to parent
-    for (const token of tokens) {
-        if (current === null || current === undefined) {
-            throw new Error(`Path does not exist: ${path}`);
-        }
-        if (Array.isArray(current)) {
-            const index = parseInt(token, 10);
-            if (isNaN(index) || index < 0 || index >= current.length) {
-                throw new Error(`Invalid array index: ${token}`);
-            }
-            current = current[index];
-        }
-        else if (typeof current === 'object') {
-            if (!(token in current)) {
-                // Create intermediate object
-                current[token] = {};
-            }
-            current = current[token];
-        }
-        else {
-            throw new Error(`Cannot traverse non-object: ${path}`);
-        }
-    }
-    // Add value
-    if (Array.isArray(current)) {
-        const index = lastToken === '-' ? current.length : parseInt(lastToken, 10);
-        if (isNaN(index) || index < 0 || index > current.length) {
-            throw new Error(`Invalid array index for add: ${lastToken}`);
-        }
-        current.splice(index, 0, structuredClone(value));
-    }
-    else if (typeof current === 'object' && current !== null) {
-        current[lastToken] = structuredClone(value);
-    }
-    else {
-        throw new Error(`Cannot add value at path: ${path}`);
-    }
-}
-/**
- * Apply a JSON Patch to a document
- * Returns result with success status and either new document or error info
- */
-export function applyPatch(document, patch) {
-    // Validate first
-    const validation = validatePatch(patch);
-    if (!validation.valid) {
-        return {
-            success: false,
-            document,
-            error: validation.error,
-        };
-    }
-    let result = structuredClone(document);
-    for (let i = 0; i < patch.length; i++) {
-        try {
-            result = applyOperation(result, patch[i]);
-        }
-        catch (error) {
-            return {
-                success: false,
-                document, // Return original document (rollback)
-                error: toErrorMessage(error),
-                failedOperationIndex: i,
-            };
-        }
-    }
-    return {
-        success: true,
-        document: result,
-    };
-}
-/**
- * Apply a JSON Patch atomically with automatic rollback on failure
- * Returns the new document if successful, throws on error
- */
-export function applyPatchAtomic(document, patch) {
-    const result = applyPatch(document, patch);
-    if (!result.success) {
-        throw new Error(result.error ?? 'Patch application failed');
-    }
-    return result.document;
-}
-// ============================================================================
-// Diff Computation
-// ============================================================================
-/**
- * Deep equality comparison for JSON values
- */
-export function deepEqual(a, b) {
-    if (a === b)
-        return true;
-    if (a === null || b === null)
-        return a === b;
-    if (typeof a !== typeof b)
-        return false;
-    if (typeof a !== 'object')
-        return a === b;
-    if (Array.isArray(a)) {
-        if (!Array.isArray(b))
-            return false;
-        if (a.length !== b.length)
-            return false;
-        return a.every((val, i) => deepEqual(val, b[i]));
-    }
-    const aObj = a;
-    const bObj = b;
-    const aKeys = Object.keys(aObj);
-    const bKeys = Object.keys(bObj);
-    if (aKeys.length !== bKeys.length)
-        return false;
-    return aKeys.every((key) => key in bObj && deepEqual(aObj[key], bObj[key]));
-}
-/**
- * Compute the JSON Patch to transform oldState into newState
- */
-export function computeDiff(oldState, newState, config = {}) {
-    const { maxDepth = Infinity } = config;
-    const operations = [];
-    computeDiffRecursive(oldState, newState, '', operations, 0, maxDepth);
-    return operations;
-}
-/**
- * Recursive diff computation
- */
-function computeDiffRecursive(oldVal, newVal, path, ops, depth, maxDepth) {
-    // If values are equal, no operation needed
-    if (deepEqual(oldVal, newVal)) {
-        return;
-    }
-    // If types differ or we're at max depth, replace
-    if (typeof oldVal !== typeof newVal ||
-        oldVal === null ||
-        newVal === null ||
-        depth >= maxDepth) {
-        if (oldVal === undefined) {
-            ops.push({ op: 'add', path, value: newVal });
-        }
-        else if (newVal === undefined) {
-            ops.push({ op: 'remove', path });
-        }
-        else {
-            ops.push({ op: 'replace', path, value: newVal });
-        }
-        return;
-    }
-    // Handle arrays
-    if (Array.isArray(oldVal) && Array.isArray(newVal)) {
-        computeArrayDiff(oldVal, newVal, path, ops, depth, maxDepth);
-        return;
-    }
-    // Handle objects
-    if (typeof oldVal === 'object' && typeof newVal === 'object') {
-        const oldObj = oldVal;
-        const newObj = newVal;
-        // Find removed keys
-        for (const key of Object.keys(oldObj)) {
-            if (!(key in newObj)) {
-                ops.push({ op: 'remove', path: buildPath([...parsePath(path), key]) });
-            }
-        }
-        // Find added and changed keys
-        for (const key of Object.keys(newObj)) {
-            const childPath = buildPath([...parsePath(path), key]);
-            if (!(key in oldObj)) {
-                ops.push({ op: 'add', path: childPath, value: newObj[key] });
-            }
-            else {
-                computeDiffRecursive(oldObj[key], newObj[key], childPath, ops, depth + 1, maxDepth);
-            }
-        }
-        return;
-    }
-    // Primitive values that differ
-    ops.push({ op: 'replace', path, value: newVal });
-}
-/**
- * Compute diff for arrays
- * Uses simple index-based comparison for efficiency
- */
-function computeArrayDiff(oldArr, newArr, path, ops, depth, maxDepth) {
-    const maxLen = Math.max(oldArr.length, newArr.length);
-    // Process from end to start to preserve indices during removal
-    const removals = [];
-    const modifications = [];
-    for (let i = 0; i < maxLen; i++) {
-        const childPath = `${path}/${i}`;
-        if (i >= newArr.length) {
-            // Element removed
-            removals.push({ op: 'remove', path: childPath });
-        }
-        else if (i >= oldArr.length) {
-            // Element added
-            modifications.push({ op: 'add', path: childPath, value: newArr[i] });
-        }
-        else if (!deepEqual(oldArr[i], newArr[i])) {
-            // Element changed
-            const oldItem = oldArr[i];
-            const newItem = newArr[i];
-            // For complex objects, recurse
-            if (typeof oldItem === 'object' &&
-                typeof newItem === 'object' &&
-                oldItem !== null &&
-                newItem !== null &&
-                !Array.isArray(oldItem) === !Array.isArray(newItem) &&
-                depth < maxDepth) {
-                computeDiffRecursive(oldItem, newItem, childPath, modifications, depth + 1, maxDepth);
-            }
-            else {
-                modifications.push({ op: 'replace', path: childPath, value: newItem });
-            }
-        }
-    }
-    // Add removals in reverse order to preserve indices
-    for (let i = removals.length - 1; i >= 0; i--) {
-        ops.push(removals[i]);
-    }
-    // Add modifications and additions
-    ops.push(...modifications);
-}
-/**
- * Create a test operation to validate state before applying patches
- */
-export function createTestOperation(path, value) {
-    return { op: 'test', path, value };
-}
-/**
- * Create an add operation
- */
-export function createAddOperation(path, value) {
-    return { op: 'add', path, value };
-}
-/**
- * Create a remove operation
- */
-export function createRemoveOperation(path) {
-    return { op: 'remove', path };
-}
-/**
- * Create a replace operation
- */
-export function createReplaceOperation(path, value) {
-    return { op: 'replace', path, value };
-}
-/**
- * Create a move operation
- */
-export function createMoveOperation(from, path) {
-    return { op: 'move', from, path };
-}
-/**
- * Create a copy operation
- */
-export function createCopyOperation(from, path) {
-    return { op: 'copy', from, path };
-}
-//# sourceMappingURL=json-patch-utils.js.map

package/dist/cli/chunks/adapter-Q6RPGMUE.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.1");process.exit(0)}
-import{a,b,c}from"./chunk-L5GEWKR3.js";import"./chunk-4XEZ562Q.js";import"./chunk-PZBYZV5M.js";import"./chunk-5C4UYXQL.js";import"./chunk-ARWSPV2C.js";import"./chunk-PNK5KHSI.js";export{a as AgentBoosterAdapter,b as createAgentBoosterAdapter,c as createAgentBoosterAdapterSync};

package/dist/cli/chunks/aqe-learning-engine-JQPXIU7C.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.1");process.exit(0)}
-import{a,b,c,d,e,f}from"./chunk-3TZRJ5QD.js";import"./chunk-SUFXUM6W.js";import"./chunk-OKS25EGZ.js";import"./chunk-CHX65QXY.js";import"./chunk-4KHSWNFW.js";import"./chunk-RDI3W4H6.js";import"./chunk-B3DWOR5R.js";import"./chunk-PGARKOE6.js";import"./chunk-XCVD57GW.js";import"./chunk-5QEXDXHQ.js";import"./chunk-N5OSH5JO.js";import"./chunk-EQ3BJS37.js";import"./chunk-HVAYG54D.js";import"./chunk-66HKJJFH.js";import"./chunk-W6K77PQR.js";import"./chunk-K4NB3MYN.js";import"./chunk-NF6SLLE6.js";import"./chunk-3NOSMJS4.js";import"./chunk-5C4UYXQL.js";import"./chunk-W5NHBYYS.js";import"./chunk-53HWWWFZ.js";import"./chunk-UE33MZOC.js";import"./chunk-ADEYBXAS.js";import"./chunk-WQZR6DS6.js";import"./chunk-WPG6SW7C.js";import"./chunk-4P7CGSRL.js";import"./chunk-SRXXPZVT.js";import"./chunk-LQI5GVH7.js";import"./chunk-PZDI7WQ3.js";import"./chunk-UGUZFUQG.js";import"./chunk-2K3QFLX2.js";import"./chunk-7FGSX4UD.js";import"./chunk-46DUU44C.js";import"./chunk-ARWSPV2C.js";import"./chunk-HU4QGCIJ.js";import"./chunk-OABFAREV.js";import"./chunk-25IWHVMW.js";import"./chunk-TCJ65NPY.js";import"./chunk-YM3GAJMN.js";import"./chunk-JW2HNT3J.js";import"./chunk-OH4SKOAM.js";import"./chunk-PNK5KHSI.js";export{b as AQELearningEngine,a as DEFAULT_ENGINE_CONFIG,c as DEFAULT_META_LEARNING_CONFIG,d as MetaLearningEngine,e as createAQELearningEngine,f as createDefaultLearningEngine};

package/dist/cli/chunks/base-5SK64NXB.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.1");process.exit(0)}
-import{a,b,c,d,e,f,g,h,i,j,k,l}from"./chunk-PBWR2SKH.js";import"./chunk-6Q7PWKWV.js";import"./chunk-DREYYJ7A.js";import"./chunk-NF6SLLE6.js";import"./chunk-3NOSMJS4.js";import"./chunk-5C4UYXQL.js";import"./chunk-W5NHBYYS.js";import"./chunk-53HWWWFZ.js";import"./chunk-UE33MZOC.js";import"./chunk-ADEYBXAS.js";import"./chunk-WQZR6DS6.js";import"./chunk-WPG6SW7C.js";import"./chunk-SRXXPZVT.js";import"./chunk-LQI5GVH7.js";import"./chunk-UGUZFUQG.js";import"./chunk-2K3QFLX2.js";import"./chunk-7FGSX4UD.js";import"./chunk-46DUU44C.js";import"./chunk-ARWSPV2C.js";import"./chunk-HU4QGCIJ.js";import"./chunk-25IWHVMW.js";import"./chunk-JW2HNT3J.js";import"./chunk-OH4SKOAM.js";import"./chunk-PNK5KHSI.js";export{l as MCPToolBase,k as defaultToolLogger,j as getKernel,i as getLLMRouter,e as getMemoryBackend,g as getSharedLLMRouter,c as getSharedMemoryBackend,a as isMemoryOnlyMode,b as registerRvfResetFn,h as resetSharedLLMRouter,d as resetSharedMemoryBackend,f as setSharedLLMRouter};

package/dist/cli/chunks/browser-workflow-WN7XNTCJ.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.1");process.exit(0)}
-import{a}from"./chunk-KHVWIUAF.js";import"./chunk-PBWR2SKH.js";import"./chunk-6Q7PWKWV.js";import"./chunk-DREYYJ7A.js";import"./chunk-NF6SLLE6.js";import"./chunk-3NOSMJS4.js";import"./chunk-5C4UYXQL.js";import"./chunk-W5NHBYYS.js";import"./chunk-53HWWWFZ.js";import"./chunk-UE33MZOC.js";import"./chunk-ADEYBXAS.js";import"./chunk-WQZR6DS6.js";import"./chunk-WPG6SW7C.js";import"./chunk-SRXXPZVT.js";import"./chunk-LQI5GVH7.js";import"./chunk-UGUZFUQG.js";import"./chunk-2K3QFLX2.js";import"./chunk-7FGSX4UD.js";import"./chunk-46DUU44C.js";import"./chunk-ARWSPV2C.js";import"./chunk-HU4QGCIJ.js";import"./chunk-25IWHVMW.js";import"./chunk-JW2HNT3J.js";import"./chunk-OH4SKOAM.js";import"./chunk-PNK5KHSI.js";export{a as BrowserWorkflowTool};

package/dist/cli/chunks/chunk-2K3QFLX2.js

@@ -1,2 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.1");process.exit(0)}
-import{a as e,c as r,d as g,g as t}from"./chunk-7FGSX4UD.js";import{b as o}from"./chunk-PNK5KHSI.js";var L=o(()=>{"use strict";e();g();t();r()});export{L as a};

package/dist/cli/chunks/chunk-53C7TGC4.js

@@ -1,4 +0,0 @@
-import{createRequire as __cr}from"module";const require=__cr(import.meta.url);if(process.argv.includes('--version')||process.argv.includes('-v')){console.log("3.15.1");process.exit(0)}
-var a=class extends Error{constructor(r){super(r),this.name="TestRunnerExecutionError"}};function y(t,r,s,e,n,i){let d=(i?.testResults??[]).filter(u=>u.status==="failed"&&(t==="vitest"&&u.message||!u.assertionResults?.some(f=>f.status==="failed"))),o;if(s===null?o="terminated without an exit code":e.passed+e.failed+e.skipped===0?o="reported zero tests":d.length>0||(i?.numRuntimeErrorTestSuites??0)>0||(i?.numFailedTestSuites??0)>0&&e.failed===0?o="reported a suite execution error":(s!==0||i?.success===!1)&&e.failed===0&&(o="failed without a failed assertion"),!o)return;let l=[...d.map(u=>u.message).filter(Boolean),n.trim()].filter(Boolean).join(`
-`).slice(0,4e3);return new a(`${t} ${o} for ${r} (exit code ${s??"unknown"}).`+(l?`
-${l}`:""))}import{mkdtempSync as p,readFileSync as m,rmSync as g}from"node:fs";import{tmpdir as R}from"node:os";import{join as c}from"node:path";function h(t,r){if(!r)return;let s;try{s=m(r,"utf-8")}catch(e){if(e.code==="ENOENT")return;throw new Error("Could not read the current Vitest JSON report.")}try{let e=JSON.parse(s);if(!e||!Array.isArray(e.testResults))throw new Error("Invalid report")}catch{throw new Error("The current Vitest JSON report is malformed.")}return s}function b(){let t=p(c(R(),"aqe-vitest-report-")),r=c(t,"report.json"),s=!1;return{path:r,args:[`--outputFile=${r}`],read:e=>h(e,r),cleanup:()=>{if(!s){s=!0;try{g(t,{recursive:!0,force:!0})}catch{}}}}}function j(t){let r=t.some(n=>/(^|[\\/])vitest(\.cmd|\.js|\.mjs)?$/i.test(n)),s=t.some((n,i)=>n==="--reporter=json"||n==="--reporter"&&t[i+1]==="json"),e=t.some(n=>n.startsWith("--outputFile"));return r&&s&&!e}export{a,y as b,b as c,j as d};