@harness-engineering/cli 1.0.1 → 1.1.0

package/dist/agents/skills/node_modules/vitest/dist/chunks/date.Bq6ZW5rf.js

@@ -0,0 +1,73 @@
+/* Ported from https://github.com/boblauer/MockDate/blob/master/src/mockdate.ts */
+/*
+The MIT License (MIT)
+
+Copyright (c) 2014 Bob Lauer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+const RealDate = Date;
+let now = null;
+class MockDate extends RealDate {
+	constructor(y, m, d, h, M, s, ms) {
+		super();
+		let date;
+		switch (arguments.length) {
+			case 0:
+				if (now !== null) date = new RealDate(now.valueOf());
+				else date = new RealDate();
+				break;
+			case 1:
+				date = new RealDate(y);
+				break;
+			default:
+				d = typeof d === "undefined" ? 1 : d;
+				h = h || 0;
+				M = M || 0;
+				s = s || 0;
+				ms = ms || 0;
+				date = new RealDate(y, m, d, h, M, s, ms);
+				break;
+		}
+		Object.setPrototypeOf(date, MockDate.prototype);
+		return date;
+	}
+}
+MockDate.UTC = RealDate.UTC;
+MockDate.now = function() {
+	return new MockDate().valueOf();
+};
+MockDate.parse = function(dateString) {
+	return RealDate.parse(dateString);
+};
+MockDate.toString = function() {
+	return RealDate.toString();
+};
+function mockDate(date) {
+	const dateObj = new RealDate(date.valueOf());
+	if (Number.isNaN(dateObj.getTime())) throw new TypeError(`mockdate: The time set is an invalid date: ${date}`);
+	// @ts-expect-error global
+	globalThis.Date = MockDate;
+	now = dateObj.valueOf();
+}
+function resetDate() {
+	globalThis.Date = RealDate;
+}
+
+export { RealDate as R, mockDate as m, resetDate as r };

package/dist/agents/skills/node_modules/vitest/dist/chunks/defaults.BOqNVLsY.js

@@ -0,0 +1,74 @@
+import nodeos__default from 'node:os';
+import './env.D4Lgay0q.js';
+import { isCI } from 'std-env';
+
+const defaultInclude = ["**/*.{test,spec}.?(c|m)[jt]s?(x)"];
+const defaultExclude = ["**/node_modules/**", "**/.git/**"];
+const benchmarkConfigDefaults = {
+	include: ["**/*.{bench,benchmark}.?(c|m)[jt]s?(x)"],
+	exclude: defaultExclude,
+	includeSource: [],
+	reporters: ["default"],
+	includeSamples: false
+};
+// These are the generic defaults for coverage. Providers may also set some provider specific defaults.
+const coverageConfigDefaults = {
+	provider: "v8",
+	enabled: false,
+	clean: true,
+	cleanOnRerun: true,
+	reportsDirectory: "./coverage",
+	exclude: [],
+	reportOnFailure: false,
+	reporter: [
+		["text", {}],
+		["html", {}],
+		["clover", {}],
+		["json", {}]
+	],
+	allowExternal: false,
+	excludeAfterRemap: false,
+	processingConcurrency: Math.min(20, nodeos__default.availableParallelism?.() ?? nodeos__default.cpus().length)
+};
+const fakeTimersDefaults = {
+	loopLimit: 1e4,
+	shouldClearNativeTimers: true
+};
+const configDefaults = Object.freeze({
+	allowOnly: !isCI,
+	isolate: true,
+	watch: !isCI && process.stdin.isTTY,
+	globals: false,
+	environment: "node",
+	clearMocks: false,
+	restoreMocks: false,
+	mockReset: false,
+	unstubGlobals: false,
+	unstubEnvs: false,
+	include: defaultInclude,
+	exclude: defaultExclude,
+	teardownTimeout: 1e4,
+	forceRerunTriggers: ["**/package.json/**", "**/{vitest,vite}.config.*/**"],
+	update: false,
+	reporters: [],
+	silent: false,
+	hideSkippedTests: false,
+	api: false,
+	ui: false,
+	uiBase: "/__vitest__/",
+	open: !isCI,
+	css: { include: [] },
+	coverage: coverageConfigDefaults,
+	fakeTimers: fakeTimersDefaults,
+	maxConcurrency: 5,
+	dangerouslyIgnoreUnhandledErrors: false,
+	typecheck: {
+		checker: "tsc",
+		include: ["**/*.{test,spec}-d.?(c|m)[jt]s?(x)"],
+		exclude: defaultExclude
+	},
+	slowTestThreshold: 300,
+	disableConsoleIntercept: false
+});
+
+export { coverageConfigDefaults as a, defaultInclude as b, configDefaults as c, defaultExclude as d, benchmarkConfigDefaults as e };

package/dist/agents/skills/node_modules/vitest/dist/chunks/env.D4Lgay0q.js

@@ -0,0 +1,8 @@
+import { isCI } from 'std-env';
+
+const isNode = typeof process < "u" && typeof process.stdout < "u" && !process.versions?.deno && !globalThis.window;
+const isDeno = typeof process < "u" && typeof process.stdout < "u" && process.versions?.deno !== void 0;
+const isWindows = (isNode || isDeno) && process.platform === "win32";
+const isTTY = (isNode || isDeno) && process.stdout?.isTTY && !isCI;
+
+export { isWindows as a, isTTY as i };

package/dist/agents/skills/node_modules/vitest/dist/chunks/environment.d.CrsxCzP1.d.ts

@@ -0,0 +1,29 @@
+import { Awaitable } from '@vitest/utils';
+
+interface EnvironmentReturn {
+	teardown: (global: any) => Awaitable<void>;
+}
+interface VmEnvironmentReturn {
+	getVmContext: () => {
+		[key: string]: any;
+	};
+	teardown: () => Awaitable<void>;
+}
+interface Environment {
+	name: string;
+	/**
+	* @deprecated use `viteEnvironment` instead. Uses `name` by default
+	*/
+	transformMode?: "web" | "ssr";
+	/**
+	* Environment initiated by the Vite server. It is usually available
+	* as `vite.server.environments.${name}`.
+	*
+	* By default, fallbacks to `name`.
+	*/
+	viteEnvironment?: "client" | "ssr" | ({} & string);
+	setupVM?: (options: Record<string, any>) => Awaitable<VmEnvironmentReturn>;
+	setup: (global: any, options: Record<string, any>) => Awaitable<EnvironmentReturn>;
+}
+
+export type { Environment as E, VmEnvironmentReturn as V, EnvironmentReturn as a };

package/dist/agents/skills/node_modules/vitest/dist/chunks/evaluatedModules.Dg1zASAC.js

@@ -0,0 +1,17 @@
+import { dirname, resolve } from 'pathe';
+import { EvaluatedModules } from 'vite/module-runner';
+
+// TODO: this is not needed in Vite 7.2+
+class VitestEvaluatedModules extends EvaluatedModules {
+	getModuleSourceMapById(id) {
+		const map = super.getModuleSourceMapById(id);
+		if (map != null && !("_patched" in map)) {
+			map._patched = true;
+			const dir = dirname(map.url);
+			map.resolvedSources = (map.map.sources || []).map((s) => resolve(dir, s || ""));
+		}
+		return map;
+	}
+}
+
+export { VitestEvaluatedModules as V };

package/dist/agents/skills/node_modules/vitest/dist/chunks/evaluatedModules.d.BxJ5omdx.d.ts

@@ -0,0 +1,7 @@
+import { EvaluatedModules } from 'vite/module-runner';
+
+declare class VitestEvaluatedModules extends EvaluatedModules {
+	getModuleSourceMapById(id: string): any;
+}
+
+export { VitestEvaluatedModules as V };

package/dist/agents/skills/node_modules/vitest/dist/chunks/git.Bm2pzPAa.js

@@ -0,0 +1,71 @@
+import { resolve } from 'pathe';
+import { x } from 'tinyexec';
+
+class VitestGit {
+	root;
+	constructor(cwd) {
+		this.cwd = cwd;
+	}
+	async resolveFilesWithGitCommand(args) {
+		let result;
+		try {
+			result = await x("git", args, { nodeOptions: { cwd: this.root } });
+		} catch (e) {
+			e.message = e.stderr;
+			throw e;
+		}
+		return result.stdout.split("\n").filter((s) => s !== "").map((changedPath) => resolve(this.root, changedPath));
+	}
+	async findChangedFiles(options) {
+		const root = await this.getRoot(this.cwd);
+		if (!root) return null;
+		this.root = root;
+		const changedSince = options.changedSince;
+		if (typeof changedSince === "string") {
+			const [committed, staged, unstaged] = await Promise.all([
+				this.getFilesSince(changedSince),
+				this.getStagedFiles(),
+				this.getUnstagedFiles()
+			]);
+			return [
+				...committed,
+				...staged,
+				...unstaged
+			];
+		}
+		const [staged, unstaged] = await Promise.all([this.getStagedFiles(), this.getUnstagedFiles()]);
+		return [...staged, ...unstaged];
+	}
+	getFilesSince(hash) {
+		return this.resolveFilesWithGitCommand([
+			"diff",
+			"--name-only",
+			`${hash}...HEAD`
+		]);
+	}
+	getStagedFiles() {
+		return this.resolveFilesWithGitCommand([
+			"diff",
+			"--cached",
+			"--name-only"
+		]);
+	}
+	getUnstagedFiles() {
+		return this.resolveFilesWithGitCommand([
+			"ls-files",
+			"--other",
+			"--modified",
+			"--exclude-standard"
+		]);
+	}
+	async getRoot(cwd) {
+		const args = ["rev-parse", "--show-cdup"];
+		try {
+			return resolve(cwd, (await x("git", args, { nodeOptions: { cwd } })).stdout.trim());
+		} catch {
+			return null;
+		}
+	}
+}
+
+export { VitestGit };

package/dist/agents/skills/node_modules/vitest/dist/chunks/global.d.B15mdLcR.d.ts

@@ -0,0 +1,99 @@
+import { PromisifyAssertion, Tester, ExpectStatic } from '@vitest/expect';
+import { Plugin } from '@vitest/pretty-format';
+import { SnapshotState } from '@vitest/snapshot';
+import { B as BenchmarkResult } from './benchmark.d.DAaHLpsq.js';
+import { U as UserConsoleLog } from './rpc.d.RH3apGEf.js';
+
+interface SnapshotMatcher<T> {
+	<U extends { [P in keyof T] : any }>(snapshot: Partial<U>, hint?: string): void;
+	(hint?: string): void;
+}
+interface InlineSnapshotMatcher<T> {
+	<U extends { [P in keyof T] : any }>(properties: Partial<U>, snapshot?: string, hint?: string): void;
+	(hint?: string): void;
+}
+declare module "@vitest/expect" {
+	interface MatcherState {
+		environment: string;
+		snapshotState: SnapshotState;
+	}
+	interface ExpectPollOptions {
+		interval?: number;
+		timeout?: number;
+		message?: string;
+	}
+	interface ExpectStatic {
+		assert: Chai.AssertStatic;
+		unreachable: (message?: string) => never;
+		soft: <T>(actual: T, message?: string) => Assertion<T>;
+		poll: <T>(actual: () => T, options?: ExpectPollOptions) => PromisifyAssertion<Awaited<T>>;
+		addEqualityTesters: (testers: Array<Tester>) => void;
+		assertions: (expected: number) => void;
+		hasAssertions: () => void;
+		addSnapshotSerializer: (plugin: Plugin) => void;
+	}
+	interface Assertion<T> {
+		matchSnapshot: SnapshotMatcher<T>;
+		toMatchSnapshot: SnapshotMatcher<T>;
+		toMatchInlineSnapshot: InlineSnapshotMatcher<T>;
+		/**
+		* Checks that an error thrown by a function matches a previously recorded snapshot.
+		*
+		* @param hint - Optional custom error message.
+		*
+		* @example
+		* expect(functionWithError).toThrowErrorMatchingSnapshot();
+		*/
+		toThrowErrorMatchingSnapshot: (hint?: string) => void;
+		/**
+		* Checks that an error thrown by a function matches an inline snapshot within the test file.
+		* Useful for keeping snapshots close to the test code.
+		*
+		* @param snapshot - Optional inline snapshot string to match.
+		* @param hint - Optional custom error message.
+		*
+		* @example
+		* const throwError = () => { throw new Error('Error occurred') };
+		* expect(throwError).toThrowErrorMatchingInlineSnapshot(`"Error occurred"`);
+		*/
+		toThrowErrorMatchingInlineSnapshot: (snapshot?: string, hint?: string) => void;
+		/**
+		* Compares the received value to a snapshot saved in a specified file.
+		* Useful for cases where snapshot content is large or needs to be shared across tests.
+		*
+		* @param filepath - Path to the snapshot file.
+		* @param hint - Optional custom error message.
+		*
+		* @example
+		* await expect(largeData).toMatchFileSnapshot('path/to/snapshot.json');
+		*/
+		toMatchFileSnapshot: (filepath: string, hint?: string) => Promise<void>;
+	}
+}
+declare module "@vitest/runner" {
+	interface TestContext {
+		/**
+		* `expect` instance bound to the current test.
+		*
+		* This API is useful for running snapshot tests concurrently because global expect cannot track them.
+		*/
+		readonly expect: ExpectStatic;
+		/** @internal */
+		_local: boolean;
+	}
+	interface TaskMeta {
+		typecheck?: boolean;
+		benchmark?: boolean;
+		failScreenshotPath?: string;
+	}
+	interface File {
+		prepareDuration?: number;
+		environmentLoad?: number;
+	}
+	interface TaskBase {
+		logs?: UserConsoleLog[];
+	}
+	interface TaskResult {
+		benchmark?: BenchmarkResult;
+	}
+}

package/dist/agents/skills/node_modules/vitest/dist/chunks/globals.DOayXfHP.js

@@ -0,0 +1,30 @@
+import { g as globalApis } from './constants.D_Q9UYh-.js';
+import { i as index } from './index.Z5E_ObnR.js';
+import './vi.2VT5v0um.js';
+import '@vitest/expect';
+import '@vitest/runner';
+import './utils.DvEY5TfP.js';
+import '@vitest/utils/timers';
+import '@vitest/runner/utils';
+import '@vitest/snapshot';
+import '@vitest/utils/error';
+import '@vitest/utils/helpers';
+import '@vitest/spy';
+import '@vitest/utils/offset';
+import '@vitest/utils/source-map';
+import './_commonjsHelpers.D26ty3Ew.js';
+import './date.Bq6ZW5rf.js';
+import './benchmark.B3N2zMcH.js';
+import './evaluatedModules.Dg1zASAC.js';
+import 'pathe';
+import 'vite/module-runner';
+import 'expect-type';
+
+function registerApiGlobally() {
+	globalApis.forEach((api) => {
+		// @ts-expect-error I know what I am doing :P
+		globalThis[api] = index[api];
+	});
+}
+
+export { registerApiGlobally };

package/dist/agents/skills/node_modules/vitest/dist/chunks/index.6Qv1eEA6.js

@@ -0,0 +1,109 @@
+import { chai } from '@vitest/expect';
+import { l as loadDiffConfig, b as loadSnapshotSerializers, t as takeCoverageInsideWorker } from './setup-common.Cm-kSBVi.js';
+import { r as rpc } from './rpc.BoxB0q7B.js';
+import { g as getWorkerState } from './utils.DvEY5TfP.js';
+import { V as VitestTestRunner, N as NodeBenchmarkRunner } from './test.B8ej_ZHS.js';
+
+function setupChaiConfig(config) {
+	Object.assign(chai.config, config);
+}
+
+async function resolveSnapshotEnvironment(config, executor) {
+	if (!config.snapshotEnvironment) {
+		const { VitestNodeSnapshotEnvironment } = await import('./node.Ce0vMQM7.js');
+		return new VitestNodeSnapshotEnvironment();
+	}
+	const mod = await executor.import(config.snapshotEnvironment);
+	if (typeof mod.default !== "object" || !mod.default) throw new Error("Snapshot environment module must have a default export object with a shape of `SnapshotEnvironment`");
+	return mod.default;
+}
+
+async function getTestRunnerConstructor(config, moduleRunner) {
+	if (!config.runner) return config.mode === "test" ? VitestTestRunner : NodeBenchmarkRunner;
+	const mod = await moduleRunner.import(config.runner);
+	if (!mod.default && typeof mod.default !== "function") throw new Error(`Runner must export a default function, but got ${typeof mod.default} imported from ${config.runner}`);
+	return mod.default;
+}
+async function resolveTestRunner(config, moduleRunner, traces) {
+	const testRunner = new (await (getTestRunnerConstructor(config, moduleRunner)))(config);
+	// inject private executor to every runner
+	Object.defineProperty(testRunner, "moduleRunner", {
+		value: moduleRunner,
+		enumerable: false,
+		configurable: false
+	});
+	if (!testRunner.config) testRunner.config = config;
+	if (!testRunner.importFile) throw new Error("Runner must implement \"importFile\" method.");
+	if ("__setTraces" in testRunner) testRunner.__setTraces(traces);
+	const [diffOptions] = await Promise.all([loadDiffConfig(config, moduleRunner), loadSnapshotSerializers(config, moduleRunner)]);
+	testRunner.config.diffOptions = diffOptions;
+	// patch some methods, so custom runners don't need to call RPC
+	const originalOnTaskUpdate = testRunner.onTaskUpdate;
+	testRunner.onTaskUpdate = async (task, events) => {
+		const p = rpc().onTaskUpdate(task, events);
+		await originalOnTaskUpdate?.call(testRunner, task, events);
+		return p;
+	};
+	// patch some methods, so custom runners don't need to call RPC
+	const originalOnTestAnnotate = testRunner.onTestAnnotate;
+	testRunner.onTestAnnotate = async (test, annotation) => {
+		const p = rpc().onTaskArtifactRecord(test.id, {
+			type: "internal:annotation",
+			location: annotation.location,
+			annotation
+		});
+		const overriddenResult = await originalOnTestAnnotate?.call(testRunner, test, annotation);
+		const vitestResult = await p;
+		return overriddenResult || vitestResult.annotation;
+	};
+	const originalOnTestArtifactRecord = testRunner.onTestArtifactRecord;
+	testRunner.onTestArtifactRecord = async (test, artifact) => {
+		const p = rpc().onTaskArtifactRecord(test.id, artifact);
+		const overriddenResult = await originalOnTestArtifactRecord?.call(testRunner, test, artifact);
+		const vitestResult = await p;
+		return overriddenResult || vitestResult;
+	};
+	const originalOnCollectStart = testRunner.onCollectStart;
+	testRunner.onCollectStart = async (file) => {
+		await rpc().onQueued(file);
+		await originalOnCollectStart?.call(testRunner, file);
+	};
+	const originalOnCollected = testRunner.onCollected;
+	testRunner.onCollected = async (files) => {
+		const state = getWorkerState();
+		files.forEach((file) => {
+			file.prepareDuration = state.durations.prepare;
+			file.environmentLoad = state.durations.environment;
+			// should be collected only for a single test file in a batch
+			state.durations.prepare = 0;
+			state.durations.environment = 0;
+		});
+		rpc().onCollected(files);
+		await originalOnCollected?.call(testRunner, files);
+	};
+	const originalOnAfterRun = testRunner.onAfterRunFiles;
+	testRunner.onAfterRunFiles = async (files) => {
+		const state = getWorkerState();
+		const coverage = await takeCoverageInsideWorker(config.coverage, moduleRunner);
+		if (coverage) rpc().onAfterSuiteRun({
+			coverage,
+			testFiles: files.map((file) => file.name).sort(),
+			environment: state.environment.viteEnvironment || state.environment.name,
+			projectName: state.ctx.projectName
+		});
+		await originalOnAfterRun?.call(testRunner, files);
+	};
+	const originalOnAfterRunTask = testRunner.onAfterRunTask;
+	testRunner.onAfterRunTask = async (test) => {
+		if (config.bail && test.result?.state === "fail") {
+			if (1 + await rpc().getCountOfFailedTests() >= config.bail) {
+				rpc().onCancel("test-failure");
+				testRunner.cancel?.("test-failure");
+			}
+		}
+		await originalOnAfterRunTask?.call(testRunner, test);
+	};
+	return testRunner;
+}
+
+export { resolveSnapshotEnvironment as a, resolveTestRunner as r, setupChaiConfig as s };