@harness-engineering/cli 1.1.0 → 1.2.0

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

@@ -1,73 +0,0 @@
-/* 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

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

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

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

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

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

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

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

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

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