@harness-engineering/cli 1.1.1 → 1.2.0

package/dist/agents/agents/skills/node_modules/vitest/dist/chunks/index.Z5E_ObnR.js

@@ -1,37 +0,0 @@
-import { b as assert, c as createExpect, g as globalExpect, i as inject, s as should, v as vi, d as vitest } from './vi.2VT5v0um.js';
-import { b as bench } from './benchmark.B3N2zMcH.js';
-import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
-import { expectTypeOf } from 'expect-type';
-import { afterAll, afterEach, beforeAll, beforeEach, describe, it, onTestFailed, onTestFinished, recordArtifact, suite, test } from '@vitest/runner';
-import { chai } from '@vitest/expect';
-
-const assertType = function assertType() {};
-
-var index = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  EvaluatedModules: VitestEvaluatedModules,
-  afterAll: afterAll,
-  afterEach: afterEach,
-  assert: assert,
-  assertType: assertType,
-  beforeAll: beforeAll,
-  beforeEach: beforeEach,
-  bench: bench,
-  chai: chai,
-  createExpect: createExpect,
-  describe: describe,
-  expect: globalExpect,
-  expectTypeOf: expectTypeOf,
-  inject: inject,
-  it: it,
-  onTestFailed: onTestFailed,
-  onTestFinished: onTestFinished,
-  recordArtifact: recordArtifact,
-  should: should,
-  suite: suite,
-  test: test,
-  vi: vi,
-  vitest: vitest
-});
-
-export { assertType as a, index as i };

package/dist/agents/agents/skills/node_modules/vitest/dist/chunks/init-forks._y3TW739.js

@@ -1,41 +0,0 @@
-import { i as init } from './init.B6MLFIaN.js';
-
-if (!process.send) throw new Error("Expected worker to be run in node:child_process");
-// Store globals in case tests overwrite them
-const processExit = process.exit.bind(process);
-const processSend = process.send.bind(process);
-const processOn = process.on.bind(process);
-const processOff = process.off.bind(process);
-const processRemoveAllListeners = process.removeAllListeners.bind(process);
-// Work-around for nodejs/node#55094
-if (process.execArgv.some((execArg) => execArg.startsWith("--prof") || execArg.startsWith("--cpu-prof") || execArg.startsWith("--heap-prof") || execArg.startsWith("--diagnostic-dir"))) processOn("SIGTERM", () => processExit());
-processOn("error", onError);
-function workerInit(options) {
-	const { runTests } = options;
-	init({
-		post: (v) => processSend(v),
-		on: (cb) => processOn("message", cb),
-		off: (cb) => processOff("message", cb),
-		teardown: () => {
-			processRemoveAllListeners("message");
-			processOff("error", onError);
-		},
-		runTests: (state, traces) => executeTests("run", state, traces),
-		collectTests: (state, traces) => executeTests("collect", state, traces),
-		setup: options.setup
-	});
-	async function executeTests(method, state, traces) {
-		try {
-			await runTests(method, state, traces);
-		} finally {
-			process.exit = processExit;
-		}
-	}
-}
-// Prevent leaving worker in loops where it tries to send message to closed main
-// thread, errors, and tries to send the error.
-function onError(error) {
-	if (error?.code === "ERR_IPC_CHANNEL_CLOSED" || error?.code === "EPIPE") processExit(1);
-}
-
-export { workerInit as w };

package/dist/agents/agents/skills/node_modules/vitest/dist/chunks/init-threads.DBO2kn-p.js

@@ -1,18 +0,0 @@
-import { isMainThread, parentPort } from 'node:worker_threads';
-import { i as init } from './init.B6MLFIaN.js';
-
-if (isMainThread || !parentPort) throw new Error("Expected worker to be run in node:worker_threads");
-function workerInit(options) {
-	const { runTests } = options;
-	init({
-		post: (response) => parentPort.postMessage(response),
-		on: (callback) => parentPort.on("message", callback),
-		off: (callback) => parentPort.off("message", callback),
-		teardown: () => parentPort.removeAllListeners("message"),
-		runTests: async (state, traces) => runTests("run", state, traces),
-		collectTests: async (state, traces) => runTests("collect", state, traces),
-		setup: options.setup
-	});
-}
-
-export { workerInit as w };

package/dist/agents/agents/skills/node_modules/vitest/dist/chunks/init.B6MLFIaN.js

@@ -1,334 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { isBuiltin } from 'node:module';
-import { pathToFileURL } from 'node:url';
-import { resolve } from 'pathe';
-import { ModuleRunner } from 'vite/module-runner';
-import { b as VitestTransport } from './startModuleRunner.DEj0jb3e.js';
-import { e as environments } from './index.CyBMJtT7.js';
-import { serializeError } from '@vitest/utils/error';
-import { T as Traces } from './traces.CCmnQaNT.js';
-import { o as onCancel, a as rpcDone, c as createRuntimeRpc } from './rpc.BoxB0q7B.js';
-import { createStackString, parseStacktrace } from '@vitest/utils/source-map';
-import { s as setupInspect } from './inspector.CvyFGlXm.js';
-import { V as VitestEvaluatedModules } from './evaluatedModules.Dg1zASAC.js';
-
-function isBuiltinEnvironment(env) {
-	return env in environments;
-}
-const isWindows = process.platform === "win32";
-const _loaders = /* @__PURE__ */ new Map();
-function createEnvironmentLoader(root, rpc) {
-	const cachedLoader = _loaders.get(root);
-	if (!cachedLoader || cachedLoader.isClosed()) {
-		_loaders.delete(root);
-		const moduleRunner = new ModuleRunner({
-			hmr: false,
-			sourcemapInterceptor: "prepareStackTrace",
-			transport: new VitestTransport({
-				async fetchModule(id, importer, options) {
-					const result = await rpc.fetch(id, importer, "__vitest__", options);
-					if ("cached" in result) return {
-						code: readFileSync(result.tmp, "utf-8"),
-						...result
-					};
-					if (isWindows && "externalize" in result)
- // TODO: vitest returns paths for external modules, but Vite returns file://
-					// https://github.com/vitejs/vite/pull/20449
-					result.externalize = isBuiltin(id) || /^(?:node:|data:|http:|https:|file:)/.test(id) ? result.externalize : pathToFileURL(result.externalize).toString();
-					return result;
-				},
-				async resolveId(id, importer) {
-					return rpc.resolve(id, importer, "__vitest__");
-				}
-			})
-		});
-		_loaders.set(root, moduleRunner);
-	}
-	return _loaders.get(root);
-}
-async function loadEnvironment(name, root, rpc, traces) {
-	if (isBuiltinEnvironment(name)) return { environment: environments[name] };
-	const loader = createEnvironmentLoader(root, rpc);
-	const packageId = name[0] === "." || name[0] === "/" ? resolve(root, name) : (await traces.$("vitest.runtime.environment.resolve", () => rpc.resolve(`vitest-environment-${name}`, void 0, "__vitest__")))?.id ?? resolve(root, name);
-	const pkg = await traces.$("vitest.runtime.environment.import", () => loader.import(packageId));
-	if (!pkg || !pkg.default || typeof pkg.default !== "object") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "setup" or/and "setupVM" method.`);
-	const environment = pkg.default;
-	if (environment.transformMode != null && environment.transformMode !== "web" && environment.transformMode !== "ssr") throw new TypeError(`Environment "${name}" is not a valid environment. Path "${packageId}" should export default object with a "transformMode" method equal to "ssr" or "web", received "${environment.transformMode}".`);
-	if (environment.transformMode) {
-		console.warn(`The Vitest environment ${environment.name} defines the "transformMode". This options was deprecated in Vitest 4 and will be removed in the next major version. Please, use "viteEnvironment" instead.`);
-		// keep for backwards compat
-		environment.viteEnvironment ??= environment.transformMode === "ssr" ? "ssr" : "client";
-	}
-	return {
-		environment,
-		loader
-	};
-}
-
-const cleanupListeners = /* @__PURE__ */ new Set();
-const moduleRunnerListeners = /* @__PURE__ */ new Set();
-function onCleanup(cb) {
-	cleanupListeners.add(cb);
-}
-async function cleanup() {
-	await Promise.all([...cleanupListeners].map((l) => l()));
-}
-function onModuleRunner(cb) {
-	moduleRunnerListeners.add(cb);
-}
-function emitModuleRunner(moduleRunner) {
-	moduleRunnerListeners.forEach((l) => l(moduleRunner));
-}
-
-const resolvingModules = /* @__PURE__ */ new Set();
-async function execute(method, ctx, worker, traces) {
-	const prepareStart = performance.now();
-	const cleanups = [setupInspect(ctx)];
-	// RPC is used to communicate between worker (be it a thread worker or child process or a custom implementation) and the main thread
-	const rpc = ctx.rpc;
-	try {
-		// do not close the RPC channel so that we can get the error messages sent to the main thread
-		cleanups.push(async () => {
-			await Promise.all(rpc.$rejectPendingCalls(({ method, reject }) => {
-				reject(/* @__PURE__ */ new Error(`[vitest-worker]: Closing rpc while "${method}" was pending`));
-			}));
-		});
-		const state = {
-			ctx,
-			evaluatedModules: new VitestEvaluatedModules(),
-			resolvingModules,
-			moduleExecutionInfo: /* @__PURE__ */ new Map(),
-			config: ctx.config,
-			environment: null,
-			durations: {
-				environment: 0,
-				prepare: prepareStart
-			},
-			rpc,
-			onCancel,
-			onCleanup: onCleanup,
-			providedContext: ctx.providedContext,
-			onFilterStackTrace(stack) {
-				return createStackString(parseStacktrace(stack));
-			},
-			metaEnv: createImportMetaEnvProxy()
-		};
-		const methodName = method === "collect" ? "collectTests" : "runTests";
-		if (!worker[methodName] || typeof worker[methodName] !== "function") throw new TypeError(`Test worker should expose "runTests" method. Received "${typeof worker.runTests}".`);
-		await worker[methodName](state, traces);
-	} finally {
-		await rpcDone().catch(() => {});
-		await Promise.all(cleanups.map((fn) => fn())).catch(() => {});
-	}
-}
-function run(ctx, worker, traces) {
-	return execute("run", ctx, worker, traces);
-}
-function collect(ctx, worker, traces) {
-	return execute("collect", ctx, worker, traces);
-}
-async function teardown() {
-	await cleanup();
-}
-const env = process.env;
-function createImportMetaEnvProxy() {
-	// packages/vitest/src/node/plugins/index.ts:146
-	const booleanKeys = [
-		"DEV",
-		"PROD",
-		"SSR"
-	];
-	return new Proxy(env, {
-		get(_, key) {
-			if (typeof key !== "string") return;
-			if (booleanKeys.includes(key)) return !!process.env[key];
-			return process.env[key];
-		},
-		set(_, key, value) {
-			if (typeof key !== "string") return true;
-			if (booleanKeys.includes(key)) process.env[key] = value ? "1" : "";
-			else process.env[key] = value;
-			return true;
-		}
-	});
-}
-
-const __vitest_worker_response__ = true;
-const memoryUsage = process.memoryUsage.bind(process);
-let reportMemory = false;
-let traces;
-/** @experimental */
-function init(worker) {
-	worker.on(onMessage);
-	if (worker.onModuleRunner) onModuleRunner(worker.onModuleRunner);
-	let runPromise;
-	let isRunning = false;
-	let workerTeardown;
-	let setupContext;
-	function send(response) {
-		worker.post(worker.serialize ? worker.serialize(response) : response);
-	}
-	async function onMessage(rawMessage) {
-		const message = worker.deserialize ? worker.deserialize(rawMessage) : rawMessage;
-		if (message?.__vitest_worker_request__ !== true) return;
-		switch (message.type) {
-			case "start": {
-				process.env.VITEST_POOL_ID = String(message.poolId);
-				process.env.VITEST_WORKER_ID = String(message.workerId);
-				reportMemory = message.options.reportMemory;
-				traces ??= await new Traces({
-					enabled: message.traces.enabled,
-					sdkPath: message.traces.sdkPath
-				}).waitInit();
-				const { environment, config, pool } = message.context;
-				const context = traces.getContextFromCarrier(message.traces.otelCarrier);
-				// record telemetry as part of "start"
-				traces.recordInitSpan(context);
-				try {
-					setupContext = {
-						environment,
-						config,
-						pool,
-						rpc: createRuntimeRpc(worker),
-						projectName: config.name || "",
-						traces
-					};
-					workerTeardown = await traces.$("vitest.runtime.setup", { context }, () => worker.setup?.(setupContext));
-					send({
-						type: "started",
-						__vitest_worker_response__
-					});
-				} catch (error) {
-					send({
-						type: "started",
-						__vitest_worker_response__,
-						error: serializeError(error)
-					});
-				}
-				break;
-			}
-			case "run":
-				// Prevent concurrent execution if worker is already running
-				if (isRunning) {
-					send({
-						type: "testfileFinished",
-						__vitest_worker_response__,
-						error: serializeError(/* @__PURE__ */ new Error("[vitest-worker]: Worker is already running tests"))
-					});
-					return;
-				}
-				try {
-					process.env.VITEST_WORKER_ID = String(message.context.workerId);
-				} catch (error) {
-					return send({
-						type: "testfileFinished",
-						__vitest_worker_response__,
-						error: serializeError(error),
-						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
-					});
-				}
-				isRunning = true;
-				try {
-					const tracesContext = traces.getContextFromCarrier(message.otelCarrier);
-					runPromise = traces.$("vitest.runtime.run", {
-						context: tracesContext,
-						attributes: {
-							"vitest.worker.specifications": traces.isEnabled() ? getFilesWithLocations(message.context.files) : [],
-							"vitest.worker.id": message.context.workerId
-						}
-					}, () => run({
-						...setupContext,
-						...message.context
-					}, worker, traces).catch((error) => serializeError(error)));
-					send({
-						type: "testfileFinished",
-						__vitest_worker_response__,
-						error: await runPromise,
-						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
-					});
-				} finally {
-					runPromise = void 0;
-					isRunning = false;
-				}
-				break;
-			case "collect":
-				// Prevent concurrent execution if worker is already running
-				if (isRunning) {
-					send({
-						type: "testfileFinished",
-						__vitest_worker_response__,
-						error: serializeError(/* @__PURE__ */ new Error("[vitest-worker]: Worker is already running tests"))
-					});
-					return;
-				}
-				try {
-					process.env.VITEST_WORKER_ID = String(message.context.workerId);
-				} catch (error) {
-					return send({
-						type: "testfileFinished",
-						__vitest_worker_response__,
-						error: serializeError(error),
-						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
-					});
-				}
-				isRunning = true;
-				try {
-					const tracesContext = traces.getContextFromCarrier(message.otelCarrier);
-					runPromise = traces.$("vitest.runtime.collect", {
-						context: tracesContext,
-						attributes: {
-							"vitest.worker.specifications": traces.isEnabled() ? getFilesWithLocations(message.context.files) : [],
-							"vitest.worker.id": message.context.workerId
-						}
-					}, () => collect({
-						...setupContext,
-						...message.context
-					}, worker, traces).catch((error) => serializeError(error)));
-					send({
-						type: "testfileFinished",
-						__vitest_worker_response__,
-						error: await runPromise,
-						usedMemory: reportMemory ? memoryUsage().heapUsed : void 0
-					});
-				} finally {
-					runPromise = void 0;
-					isRunning = false;
-				}
-				break;
-			case "stop":
-				await runPromise;
-				try {
-					const context = traces.getContextFromCarrier(message.otelCarrier);
-					const error = await traces.$("vitest.runtime.teardown", { context }, async () => {
-						const error = await teardown().catch((error) => serializeError(error));
-						await workerTeardown?.();
-						return error;
-					});
-					await traces.finish();
-					send({
-						type: "stopped",
-						error,
-						__vitest_worker_response__
-					});
-				} catch (error) {
-					send({
-						type: "stopped",
-						error: serializeError(error),
-						__vitest_worker_response__
-					});
-				}
-				worker.teardown?.();
-				break;
-		}
-	}
-}
-function getFilesWithLocations(files) {
-	return files.flatMap((file) => {
-		if (!file.testLocations) return file.filepath;
-		return file.testLocations.map((location) => {
-			return `${file}:${location}`;
-		});
-	});
-}
-
-export { emitModuleRunner as e, init as i, loadEnvironment as l };

package/dist/agents/agents/skills/node_modules/vitest/dist/chunks/inspector.CvyFGlXm.js

@@ -1,53 +0,0 @@
-import { createRequire } from 'node:module';
-import { pathToFileURL } from 'node:url';
-
-const __require = createRequire(import.meta.url);
-let inspector;
-let session;
-/**
-* Enables debugging inside `worker_threads` and `child_process`.
-* Should be called as early as possible when worker/process has been set up.
-*/
-function setupInspect(ctx) {
-	const config = ctx.config;
-	const isEnabled = config.inspector.enabled;
-	if (isEnabled) {
-		inspector = __require("node:inspector");
-		if (!(inspector.url() !== void 0)) {
-			inspector.open(config.inspector.port, config.inspector.host, config.inspector.waitForDebugger);
-			if (config.inspectBrk) {
-				const firstTestFile = typeof ctx.files[0] === "string" ? ctx.files[0] : ctx.files[0].filepath;
-				// Stop at first test file
-				if (firstTestFile) {
-					session = new inspector.Session();
-					session.connect();
-					session.post("Debugger.enable");
-					session.post("Debugger.setBreakpointByUrl", {
-						lineNumber: 0,
-						url: pathToFileURL(firstTestFile)
-					});
-				}
-			}
-		}
-	}
-	const keepOpen = shouldKeepOpen(config);
-	return function cleanup() {
-		if (isEnabled && !keepOpen && inspector) {
-			inspector.close();
-			session?.disconnect();
-		}
-	};
-}
-function closeInspector(config) {
-	const keepOpen = shouldKeepOpen(config);
-	if (inspector && !keepOpen) {
-		inspector.close();
-		session?.disconnect();
-	}
-}
-function shouldKeepOpen(config) {
-	// In watch mode the inspector can persist re-runs if isolation is disabled and a single worker is used
-	return config.watch && config.isolate === false && config.maxWorkers === 1;
-}
-
-export { closeInspector as c, setupInspect as s };

package/dist/agents/agents/skills/node_modules/vitest/dist/chunks/modules.BJuCwlRJ.js

@@ -1,36 +0,0 @@
-import { builtinModules } from 'node:module';
-
-// copied from vite
-// https://github.com/vitejs/vite/blob/814120f2ad387ca3d1e16c7dd403b04ca4b97f75/packages/vite/src/node/utils.ts#L106
-// Supported by Node, Deno, Bun
-const NODE_BUILTIN_NAMESPACE = "node:";
-// Supported by Deno
-const NPM_BUILTIN_NAMESPACE = "npm:";
-// Supported by Bun
-const BUN_BUILTIN_NAMESPACE = "bun:";
-// Some runtimes like Bun injects namespaced modules here, which is not a node builtin
-const nodeBuiltins = builtinModules.filter((id) => !id.includes(":"));
-const { bun: isBun, deno: isDeno } = process.versions;
-// TODO: Use `isBuiltin` from `node:module`, but Deno doesn't support it
-function isBuiltin(id) {
-	if (isDeno && id.startsWith(NPM_BUILTIN_NAMESPACE)) return true;
-	if (isBun && id.startsWith(BUN_BUILTIN_NAMESPACE)) return true;
-	return isNodeBuiltin(id);
-}
-function isNodeBuiltin(id) {
-	if (id.startsWith(NODE_BUILTIN_NAMESPACE)) return true;
-	return nodeBuiltins.includes(id);
-}
-const browserExternalId = "__vite-browser-external";
-const browserExternalLength = 24;
-function isBrowserExternal(id) {
-	return id.startsWith(browserExternalId);
-}
-function toBuiltin(id) {
-	if (id.startsWith(browserExternalId)) id = id.slice(browserExternalLength);
-	if (id.startsWith(NPM_BUILTIN_NAMESPACE) || id.startsWith(BUN_BUILTIN_NAMESPACE) || id.startsWith(NODE_BUILTIN_NAMESPACE)) return id;
-	if (isDeno || isBun) return id;
-	return `node:${id}`;
-}
-
-export { isBrowserExternal as a, isBuiltin as i, toBuiltin as t };

package/dist/agents/agents/skills/node_modules/vitest/dist/chunks/node.Ce0vMQM7.js

@@ -1,14 +0,0 @@
-import { NodeSnapshotEnvironment } from '@vitest/snapshot/environment';
-import { g as getWorkerState } from './utils.DvEY5TfP.js';
-import '@vitest/utils/timers';
-
-class VitestNodeSnapshotEnvironment extends NodeSnapshotEnvironment {
-	getHeader() {
-		return `// Vitest Snapshot v${this.getVersion()}, https://vitest.dev/guide/snapshot.html`;
-	}
-	resolvePath(filepath) {
-		return getWorkerState().rpc.resolveSnapshotPath(filepath);
-	}
-}
-
-export { VitestNodeSnapshotEnvironment };

package/dist/agents/agents/skills/node_modules/vitest/dist/chunks/plugin.d.CtqpEehP.d.ts

@@ -1,38 +0,0 @@
-import { DevEnvironment } from 'vite';
-import { V as Vitest, T as TestProject, b as TestProjectConfiguration } from './reporters.d.CWXNI2jG.js';
-
-/**
-* Generate a unique cache identifier.
-*
-* Return `false` to disable caching of the file.
-* @experimental
-*/
-interface CacheKeyIdGenerator {
-	(context: CacheKeyIdGeneratorContext): string | undefined | null | false;
-}
-/**
-* @experimental
-*/
-interface CacheKeyIdGeneratorContext {
-	environment: DevEnvironment;
-	id: string;
-	sourceCode: string;
-}
-
-interface VitestPluginContext {
-	vitest: Vitest;
-	project: TestProject;
-	injectTestProjects: (config: TestProjectConfiguration | TestProjectConfiguration[]) => Promise<TestProject[]>;
-	/**
-	* Define a generator that will be applied before hashing the cache key.
-	*
-	* Use this to make sure Vitest generates correct hash. It is a good idea
-	* to define this function if your plugin can be registered with different options.
-	*
-	* This is called only if `experimental.fsModuleCache` is defined.
-	* @experimental
-	*/
-	experimental_defineCacheKeyGenerator: (callback: CacheKeyIdGenerator) => void;
-}
-
-export type { CacheKeyIdGenerator as C, VitestPluginContext as V, CacheKeyIdGeneratorContext as a };