@venos-inc/venos 0.1.5 → 0.1.7

package/etc/mcp-server/node_modules/@vitest/runner/dist/types.d.ts

@@ -1,136 +1,163 @@
 import { DiffOptions } from '@vitest/utils/diff';
-import { r as SequenceHooks, s as SequenceSetupFiles, F as File, T as Task, a as Test, C as Custom, S as Suite, G as TaskResultPack, v as TaskContext, E as ExtendedContext } from './tasks-3ZnPj1LR.js';
-export { A as AfterAllListener, e as AfterEachListener, B as BeforeAllListener, d as BeforeEachListener, j as CustomAPI, D as DoneCallback, l as Fixture, m as FixtureFn, n as FixtureOptions, o as Fixtures, H as HookCleanupCallback, p as HookListener, I as InferFixturesTypes, O as OnTestFailedHandler, g as OnTestFinishedHandler, R as RunMode, q as RuntimeContext, i as SuiteAPI, k as SuiteCollector, t as SuiteFactory, h as SuiteHooks, u as TaskBase, w as TaskCustomOptions, f as TaskHook, x as TaskMeta, y as TaskPopulated, z as TaskResult, J as TaskState, j as TestAPI, K as TestContext, L as TestFunction, M as TestOptions, U as Use } from './tasks-3ZnPj1LR.js';
+import { F as File, a as Test, S as Suite, L as TaskResultPack, z as TaskEventPack, N as TestAnnotation, U as TestContext, I as ImportDuration, t as SequenceHooks, u as SequenceSetupFiles } from './tasks.d-CkscK4of.js';
+export { A as AfterAllListener, b as AfterEachListener, B as BeforeAllListener, d as BeforeEachListener, g as Custom, j as CustomAPI, D as DoneCallback, E as ExtendedContext, m as Fixture, n as FixtureFn, o as FixtureOptions, p as Fixtures, H as HookCleanupCallback, q as HookListener, r as InferFixturesTypes, O as OnTestFailedHandler, f as OnTestFinishedHandler, R as RunMode, s as RuntimeContext, k as SuiteAPI, l as SuiteCollector, v as SuiteFactory, h as SuiteHooks, T as Task, w as TaskBase, x as TaskContext, y as TaskCustomOptions, e as TaskHook, G as TaskMeta, J as TaskPopulated, K as TaskResult, M as TaskState, i as TaskUpdateEvent, j as TestAPI, P as TestAnnotationLocation, Q as TestAttachment, V as TestFunction, W as TestOptions, X as Use } from './tasks.d-CkscK4of.js';
 import '@vitest/utils';
 
 /**
- * This is a subset of Vitest config that's required for the runner to work.
- */
+* This is a subset of Vitest config that's required for the runner to work.
+*/
 interface VitestRunnerConfig {
-    root: string;
-    setupFiles: string[];
-    name?: string;
-    passWithNoTests: boolean;
-    testNamePattern?: RegExp;
-    allowOnly?: boolean;
-    sequence: {
-        shuffle?: boolean;
-        concurrent?: boolean;
-        seed: number;
-        hooks: SequenceHooks;
-        setupFiles: SequenceSetupFiles;
-    };
-    chaiConfig?: {
-        truncateThreshold?: number;
-    };
-    maxConcurrency: number;
-    testTimeout: number;
-    hookTimeout: number;
-    retry: number;
-    includeTaskLocation?: boolean;
-    diffOptions?: DiffOptions;
+	root: string;
+	setupFiles: string[];
+	name?: string;
+	passWithNoTests: boolean;
+	testNamePattern?: RegExp;
+	allowOnly?: boolean;
+	sequence: {
+		shuffle?: boolean
+		concurrent?: boolean
+		seed: number
+		hooks: SequenceHooks
+		setupFiles: SequenceSetupFiles
+	};
+	chaiConfig?: {
+		truncateThreshold?: number
+	};
+	maxConcurrency: number;
+	testTimeout: number;
+	hookTimeout: number;
+	retry: number;
+	includeTaskLocation?: boolean;
+	diffOptions?: DiffOptions;
 }
-type VitestRunnerImportSource = 'collect' | 'setup';
+/**
+* Possible options to run a single file in a test.
+*/
+interface FileSpecification {
+	filepath: string;
+	testLocations: number[] | undefined;
+}
+type VitestRunnerImportSource = "collect" | "setup";
 interface VitestRunnerConstructor {
-    new (config: VitestRunnerConfig): VitestRunner;
+	new (config: VitestRunnerConfig): VitestRunner;
 }
-type CancelReason = 'keyboard-input' | 'test-failure' | (string & Record<string, never>);
+type CancelReason = "keyboard-input" | "test-failure" | (string & Record<string, never>);
 interface VitestRunner {
-    /**
-     * First thing that's getting called before actually collecting and running tests.
-     */
-    onBeforeCollect?: (paths: string[]) => unknown;
-    /**
-     * Called after the file task was created but not collected yet.
-     */
-    onCollectStart?: (file: File) => unknown;
-    /**
-     * Called after collecting tests and before "onBeforeRun".
-     */
-    onCollected?: (files: File[]) => unknown;
-    /**
-     * Called when test runner should cancel next test runs.
-     * Runner should listen for this method and mark tests and suites as skipped in
-     * "onBeforeRunSuite" and "onBeforeRunTask" when called.
-     */
-    onCancel?: (reason: CancelReason) => unknown;
-    /**
-     * Called before running a single test. Doesn't have "result" yet.
-     */
-    onBeforeRunTask?: (test: Task) => unknown;
-    /**
-     * Called before actually running the test function. Already has "result" with "state" and "startTime".
-     */
-    onBeforeTryTask?: (test: Task, options: {
-        retry: number;
-        repeats: number;
-    }) => unknown;
-    /**
-     * When the task has finished running, but before cleanup hooks are called
-     */
-    onTaskFinished?: (test: Test | Custom) => unknown;
-    /**
-     * Called after result and state are set.
-     */
-    onAfterRunTask?: (test: Task) => unknown;
-    /**
-     * Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
-     */
-    onAfterTryTask?: (test: Task, options: {
-        retry: number;
-        repeats: number;
-    }) => unknown;
-    /**
-     * Called before running a single suite. Doesn't have "result" yet.
-     */
-    onBeforeRunSuite?: (suite: Suite) => unknown;
-    /**
-     * Called after running a single suite. Has state and result.
-     */
-    onAfterRunSuite?: (suite: Suite) => unknown;
-    /**
-     * If defined, will be called instead of usual Vitest suite partition and handling.
-     * "before" and "after" hooks will not be ignored.
-     */
-    runSuite?: (suite: Suite) => Promise<void>;
-    /**
-     * If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
-     * "before" and "after" hooks will not be ignored.
-     */
-    runTask?: (test: Task) => Promise<void>;
-    /**
-     * Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
-     */
-    onTaskUpdate?: (task: TaskResultPack[]) => Promise<void>;
-    /**
-     * Called before running all tests in collected paths.
-     */
-    onBeforeRunFiles?: (files: File[]) => unknown;
-    /**
-     * Called right after running all tests in collected paths.
-     */
-    onAfterRunFiles?: (files: File[]) => unknown;
-    /**
-     * Called when new context for a test is defined. Useful if you want to add custom properties to the context.
-     * If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
-     *
-     * This method is called for both "test" and "custom" handlers.
-     *
-     * @see https://vitest.dev/advanced/runner.html#your-task-function
-     */
-    extendTaskContext?: <T extends Test | Custom>(context: TaskContext<T>) => ExtendedContext<T>;
-    /**
-     * Called when test and setup files are imported. Can be called in two situations: when collecting tests and when importing setup files.
-     */
-    importFile: (filepath: string, source: VitestRunnerImportSource) => unknown;
-    /**
-     * Publicly available configuration.
-     */
-    config: VitestRunnerConfig;
-    /**
-     * The name of the current pool. Can affect how stack trace is inferred on the server side.
-     */
-    pool?: string;
+	/**
+	* First thing that's getting called before actually collecting and running tests.
+	*/
+	onBeforeCollect?: (paths: string[]) => unknown;
+	/**
+	* Called after the file task was created but not collected yet.
+	*/
+	onCollectStart?: (file: File) => unknown;
+	/**
+	* Called after collecting tests and before "onBeforeRun".
+	*/
+	onCollected?: (files: File[]) => unknown;
+	/**
+	* Called when test runner should cancel next test runs.
+	* Runner should listen for this method and mark tests and suites as skipped in
+	* "onBeforeRunSuite" and "onBeforeRunTask" when called.
+	*/
+	cancel?: (reason: CancelReason) => unknown;
+	/**
+	* Called before running a single test. Doesn't have "result" yet.
+	*/
+	onBeforeRunTask?: (test: Test) => unknown;
+	/**
+	* Called before actually running the test function. Already has "result" with "state" and "startTime".
+	*/
+	onBeforeTryTask?: (test: Test, options: {
+		retry: number
+		repeats: number
+	}) => unknown;
+	/**
+	* When the task has finished running, but before cleanup hooks are called
+	*/
+	onTaskFinished?: (test: Test) => unknown;
+	/**
+	* Called after result and state are set.
+	*/
+	onAfterRunTask?: (test: Test) => unknown;
+	/**
+	* Called right after running the test function. Doesn't have new state yet. Will not be called, if the test function throws.
+	*/
+	onAfterTryTask?: (test: Test, options: {
+		retry: number
+		repeats: number
+	}) => unknown;
+	/**
+	* Called before running a single suite. Doesn't have "result" yet.
+	*/
+	onBeforeRunSuite?: (suite: Suite) => unknown;
+	/**
+	* Called after running a single suite. Has state and result.
+	*/
+	onAfterRunSuite?: (suite: Suite) => unknown;
+	/**
+	* If defined, will be called instead of usual Vitest suite partition and handling.
+	* "before" and "after" hooks will not be ignored.
+	*/
+	runSuite?: (suite: Suite) => Promise<void>;
+	/**
+	* If defined, will be called instead of usual Vitest handling. Useful, if you have your custom test function.
+	* "before" and "after" hooks will not be ignored.
+	*/
+	runTask?: (test: Test) => Promise<void>;
+	/**
+	* Called, when a task is updated. The same as "onTaskUpdate" in a reporter, but this is running in the same thread as tests.
+	*/
+	onTaskUpdate?: (task: TaskResultPack[], events: TaskEventPack[]) => Promise<void>;
+	/**
+	* Called when annotation is added via the `context.annotate` method.
+	*/
+	onTestAnnotate?: (test: Test, annotation: TestAnnotation) => Promise<TestAnnotation>;
+	/**
+	* Called before running all tests in collected paths.
+	*/
+	onBeforeRunFiles?: (files: File[]) => unknown;
+	/**
+	* Called right after running all tests in collected paths.
+	*/
+	onAfterRunFiles?: (files: File[]) => unknown;
+	/**
+	* Called when new context for a test is defined. Useful if you want to add custom properties to the context.
+	* If you only want to define custom context, consider using "beforeAll" in "setupFiles" instead.
+	*
+	* @see https://vitest.dev/advanced/runner#your-task-function
+	*/
+	extendTaskContext?: (context: TestContext) => TestContext;
+	/**
+	* Called when test and setup files are imported. Can be called in two situations: when collecting tests and when importing setup files.
+	*/
+	importFile: (filepath: string, source: VitestRunnerImportSource) => unknown;
+	/**
+	* Function that is called when the runner attempts to get the value when `test.extend` is used with `{ injected: true }`
+	*/
+	injectValue?: (key: string) => unknown;
+	/**
+	* Gets the time spent importing each individual non-externalized file that Vitest collected.
+	*/
+	getImportDurations?: () => Record<string, ImportDuration>;
+	/**
+	* Publicly available configuration.
+	*/
+	config: VitestRunnerConfig;
+	/**
+	* The name of the current pool. Can affect how stack trace is inferred on the server side.
+	*/
+	pool?: string;
+	/**
+	* Return the worker context for fixtures specified with `scope: 'worker'`
+	*/
+	getWorkerContext?: () => Record<string, unknown>;
+	onCleanupWorkerContext?: (cleanup: () => unknown) => void;
+	/** @private */
+	_currentTaskStartTime?: number;
+	/** @private */
+	_currentTaskTimeout?: number;
 }
 
-export { type CancelReason, Custom, ExtendedContext, File, SequenceHooks, SequenceSetupFiles, Suite, Task, TaskContext, TaskResultPack, Test, type VitestRunner, type VitestRunnerConfig, type VitestRunnerConstructor, type VitestRunnerImportSource };
+export { File, ImportDuration, SequenceHooks, SequenceSetupFiles, Suite, TaskEventPack, TaskResultPack, Test, TestAnnotation, TestContext };
+export type { CancelReason, FileSpecification, VitestRunner, VitestRunnerConfig, VitestRunnerConstructor, VitestRunnerImportSource };

package/etc/mcp-server/node_modules/@vitest/runner/dist/utils.d.ts

@@ -1,28 +1,41 @@
-import { S as Suite, F as File, T as Task, a as Test, C as Custom } from './tasks-3ZnPj1LR.js';
-export { b as ChainableFunction, c as createChainable } from './tasks-3ZnPj1LR.js';
+import { S as Suite, F as File, T as Task, a as Test } from './tasks.d-CkscK4of.js';
+export { C as ChainableFunction, c as createChainable } from './tasks.d-CkscK4of.js';
 import { Arrayable } from '@vitest/utils';
 
 /**
- * If any tasks been marked as `only`, mark all other tasks as `skip`.
- */
-declare function interpretTaskModes(suite: Suite, namePattern?: string | RegExp, onlyMode?: boolean, parentIsOnly?: boolean, allowOnly?: boolean): void;
+* If any tasks been marked as `only`, mark all other tasks as `skip`.
+*/
+declare function interpretTaskModes(file: Suite, namePattern?: string | RegExp, testLocations?: number[] | undefined, onlyMode?: boolean, parentIsOnly?: boolean, allowOnly?: boolean): void;
 declare function someTasksAreOnly(suite: Suite): boolean;
 declare function generateHash(str: string): string;
 declare function calculateSuiteHash(parent: Suite): void;
 declare function createFileTask(filepath: string, root: string, projectName: string | undefined, pool?: string): File;
+/**
+* Generate a unique ID for a file based on its path and project name
+* @param file File relative to the root of the project to keep ID the same between different machines
+* @param projectName The name of the test project
+*/
+declare function generateFileHash(file: string, projectName: string | undefined): string;
 
 /**
- * Return a function for running multiple async operations with limited concurrency.
- */
-declare function limitConcurrency(concurrency?: number): <Args extends unknown[], T>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>;
+* Return a function for running multiple async operations with limited concurrency.
+*/
+declare function limitConcurrency(concurrency?: number): <
+	Args extends unknown[],
+	T
+>(func: (...args: Args) => PromiseLike<T> | T, ...args: Args) => Promise<T>;
 
 /**
- * Partition in tasks groups by consecutive concurrent
- */
+* Partition in tasks groups by consecutive concurrent
+*/
 declare function partitionSuiteChildren(suite: Suite): Task[][];
 
-declare function isAtomTest(s: Task): s is Test | Custom;
-declare function getTests(suite: Arrayable<Task>): (Test | Custom)[];
+/**
+* @deprecated use `isTestCase` instead
+*/
+declare function isAtomTest(s: Task): s is Test;
+declare function isTestCase(s: Task): s is Test;
+declare function getTests(suite: Arrayable<Task>): Test[];
 declare function getTasks(tasks?: Arrayable<Task>): Task[];
 declare function getSuites(suite: Arrayable<Task>): Suite[];
 declare function hasTests(suite: Arrayable<Suite>): boolean;
@@ -31,4 +44,4 @@ declare function getNames(task: Task): string[];
 declare function getFullName(task: Task, separator?: string): string;
 declare function getTestName(task: Task, separator?: string): string;
 
-export { calculateSuiteHash, createFileTask, generateHash, getFullName, getNames, getSuites, getTasks, getTestName, getTests, hasFailed, hasTests, interpretTaskModes, isAtomTest, limitConcurrency, partitionSuiteChildren, someTasksAreOnly };
+export { calculateSuiteHash, createFileTask, generateFileHash, generateHash, getFullName, getNames, getSuites, getTasks, getTestName, getTests, hasFailed, hasTests, interpretTaskModes, isAtomTest, isTestCase, limitConcurrency, partitionSuiteChildren, someTasksAreOnly };

package/etc/mcp-server/node_modules/@vitest/runner/dist/utils.js

@@ -1,4 +1,6 @@
-export { a as calculateSuiteHash, c as createChainable, b as createFileTask, g as generateHash, d as getFullName, e as getNames, f as getSuites, h as getTasks, j as getTestName, k as getTests, m as hasFailed, n as hasTests, i as interpretTaskModes, o as isAtomTest, l as limitConcurrency, p as partitionSuiteChildren, s as someTasksAreOnly } from './chunk-tasks.js';
+export { v as calculateSuiteHash, r as createChainable, w as createFileTask, x as generateFileHash, y as generateHash, D as getFullName, E as getNames, F as getSuites, G as getTasks, H as getTestName, I as getTests, J as hasFailed, K as hasTests, z as interpretTaskModes, L as isAtomTest, M as isTestCase, B as limitConcurrency, C as partitionSuiteChildren, A as someTasksAreOnly } from './chunk-hooks.js';
+import '@vitest/utils';
+import '@vitest/utils/source-map';
 import '@vitest/utils/error';
+import 'strip-literal';
 import 'pathe';
-import '@vitest/utils';

package/etc/mcp-server/node_modules/@vitest/runner/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@vitest/runner",
   "type": "module",
-  "version": "2.1.9",
+  "version": "3.2.6",
   "description": "Vitest test runner",
   "license": "MIT",
   "funding": "https://opencollective.com/vitest",
@@ -38,8 +38,9 @@
     "dist"
   ],
   "dependencies": {
-    "pathe": "^1.1.2",
-    "@vitest/utils": "2.1.9"
+    "pathe": "^2.0.3",
+    "strip-literal": "^3.0.0",
+    "@vitest/utils": "3.2.6"
   },
   "scripts": {
     "build": "rimraf dist && rollup -c",

package/etc/mcp-server/node_modules/@vitest/snapshot/dist/environment.d-DHdQ1Csl.d.ts

@@ -0,0 +1,22 @@
+interface ParsedStack {
+	method: string;
+	file: string;
+	line: number;
+	column: number;
+}
+
+interface SnapshotEnvironment {
+	getVersion: () => string;
+	getHeader: () => string;
+	resolvePath: (filepath: string) => Promise<string>;
+	resolveRawPath: (testPath: string, rawPath: string) => Promise<string>;
+	saveSnapshotFile: (filepath: string, snapshot: string) => Promise<void>;
+	readSnapshotFile: (filepath: string) => Promise<string | null>;
+	removeSnapshotFile: (filepath: string) => Promise<void>;
+	processStackTrace?: (stack: ParsedStack) => ParsedStack;
+}
+interface SnapshotEnvironmentOptions {
+	snapshotsDirName?: string;
+}
+
+export type { ParsedStack as P, SnapshotEnvironment as S, SnapshotEnvironmentOptions as a };

package/etc/mcp-server/node_modules/@vitest/snapshot/dist/environment.d.ts

@@ -1,16 +1,16 @@
-import { S as SnapshotEnvironment, a as SnapshotEnvironmentOptions } from './environment-Ddx0EDtY.js';
+import { S as SnapshotEnvironment, a as SnapshotEnvironmentOptions } from './environment.d-DHdQ1Csl.js';
 
 declare class NodeSnapshotEnvironment implements SnapshotEnvironment {
-    private options;
-    constructor(options?: SnapshotEnvironmentOptions);
-    getVersion(): string;
-    getHeader(): string;
-    resolveRawPath(testPath: string, rawPath: string): Promise<string>;
-    resolvePath(filepath: string): Promise<string>;
-    prepareDirectory(dirPath: string): Promise<void>;
-    saveSnapshotFile(filepath: string, snapshot: string): Promise<void>;
-    readSnapshotFile(filepath: string): Promise<string | null>;
-    removeSnapshotFile(filepath: string): Promise<void>;
+	private options;
+	constructor(options?: SnapshotEnvironmentOptions);
+	getVersion(): string;
+	getHeader(): string;
+	resolveRawPath(testPath: string, rawPath: string): Promise<string>;
+	resolvePath(filepath: string): Promise<string>;
+	prepareDirectory(dirPath: string): Promise<void>;
+	saveSnapshotFile(filepath: string, snapshot: string): Promise<void>;
+	readSnapshotFile(filepath: string): Promise<string | null>;
+	removeSnapshotFile(filepath: string): Promise<void>;
 }
 
 export { NodeSnapshotEnvironment, SnapshotEnvironment };

package/etc/mcp-server/node_modules/@vitest/snapshot/dist/environment.js

@@ -1,43 +1,40 @@
 import { promises, existsSync } from 'node:fs';
-import { isAbsolute, resolve, dirname, join, basename } from 'pathe';
+import { resolve, isAbsolute, dirname, join, basename } from 'pathe';
 
 class NodeSnapshotEnvironment {
-  constructor(options = {}) {
-    this.options = options;
-  }
-  getVersion() {
-    return "1";
-  }
-  getHeader() {
-    return `// Snapshot v${this.getVersion()}`;
-  }
-  async resolveRawPath(testPath, rawPath) {
-    return isAbsolute(rawPath) ? rawPath : resolve(dirname(testPath), rawPath);
-  }
-  async resolvePath(filepath) {
-    return join(
-      join(dirname(filepath), this.options.snapshotsDirName ?? "__snapshots__"),
-      `${basename(filepath)}.snap`
-    );
-  }
-  async prepareDirectory(dirPath) {
-    await promises.mkdir(dirPath, { recursive: true });
-  }
-  async saveSnapshotFile(filepath, snapshot) {
-    await promises.mkdir(dirname(filepath), { recursive: true });
-    await promises.writeFile(filepath, snapshot, "utf-8");
-  }
-  async readSnapshotFile(filepath) {
-    if (!existsSync(filepath)) {
-      return null;
-    }
-    return promises.readFile(filepath, "utf-8");
-  }
-  async removeSnapshotFile(filepath) {
-    if (existsSync(filepath)) {
-      await promises.unlink(filepath);
-    }
-  }
+	constructor(options = {}) {
+		this.options = options;
+	}
+	getVersion() {
+		return "1";
+	}
+	getHeader() {
+		return `// Snapshot v${this.getVersion()}`;
+	}
+	async resolveRawPath(testPath, rawPath) {
+		return isAbsolute(rawPath) ? rawPath : resolve(dirname(testPath), rawPath);
+	}
+	async resolvePath(filepath) {
+		return join(join(dirname(filepath), this.options.snapshotsDirName ?? "__snapshots__"), `${basename(filepath)}.snap`);
+	}
+	async prepareDirectory(dirPath) {
+		await promises.mkdir(dirPath, { recursive: true });
+	}
+	async saveSnapshotFile(filepath, snapshot) {
+		await promises.mkdir(dirname(filepath), { recursive: true });
+		await promises.writeFile(filepath, snapshot, "utf-8");
+	}
+	async readSnapshotFile(filepath) {
+		if (!existsSync(filepath)) {
+			return null;
+		}
+		return promises.readFile(filepath, "utf-8");
+	}
+	async removeSnapshotFile(filepath) {
+		if (existsSync(filepath)) {
+			await promises.unlink(filepath);
+		}
+	}
 }
 
 export { NodeSnapshotEnvironment };