@harness-engineering/cli 1.0.1 → 1.1.0

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

@@ -0,0 +1,37 @@
+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

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,334 @@
+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

@@ -0,0 +1,53 @@
+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

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,14 @@
+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

@@ -0,0 +1,38 @@
+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 };