ryco-cli 0.1.3 → 0.1.5

package/dist/SourceControlProviderDiscoveryCatalog-DqQVhwYM.cjs

@@ -0,0 +1,676 @@
+#!/usr/bin/env node
+
+const require_collectUint8StreamText = require("./collectUint8StreamText-DbCOJom3.cjs");
+let effect = require("effect");
+let effect_unstable_process = require("effect/unstable/process");
+//#region ../../packages/shared/src/schemaJson.ts
+const decodeJsonResult = (schema) => {
+	const decode = effect.Schema.decodeExit(effect.Schema.fromJsonString(schema));
+	return (input) => {
+		const result = decode(input);
+		if (effect.Exit.isFailure(result)) return effect.Result.fail(result.cause);
+		return effect.Result.succeed(result.value);
+	};
+};
+const formatSchemaError = (cause) => {
+	const squashed = effect.Cause.squash(cause);
+	return effect.Schema.isSchemaError(squashed) ? effect.SchemaIssue.makeFormatterDefault()(squashed.issue) : effect.Cause.pretty(cause);
+};
+/**
+* A `Getter` that parses a lenient JSON string (tolerating trailing commas
+* and JS-style comments) into an unknown value.
+*
+* Mirrors `SchemaGetter.parseJson()` but uses `parseLenientJson` instead
+* of `JSON.parse`.
+*/
+const parseLenientJsonGetter = effect.SchemaGetter.onSome((input) => effect.Effect.try({
+	try: () => {
+		let stripped = input.replace(/("(?:[^"\\]|\\.)*")|\/\/[^\n]*/g, (match, stringLiteral) => stringLiteral ? match : "");
+		stripped = stripped.replace(/("(?:[^"\\]|\\.)*")|\/\*[\s\S]*?\*\//g, (match, stringLiteral) => stringLiteral ? match : "");
+		stripped = stripped.replace(/,(\s*[}\]])/g, "$1");
+		return effect.Option.some(JSON.parse(stripped));
+	},
+	catch: (e) => new effect.SchemaIssue.InvalidValue(effect.Option.some(input), { message: String(e) })
+}));
+/**
+* Schema transformation: lenient JSONC string ↔ unknown.
+*
+* Same API as `SchemaTransformation.fromJsonString`, but the decode side
+* strips trailing commas and JS-style comments before parsing.
+* Encoding produces strict JSON via `JSON.stringify`.
+*/
+const fromLenientJsonString = new effect.SchemaTransformation.Transformation(parseLenientJsonGetter, effect.SchemaGetter.stringifyJson());
+/**
+* Build a schema that decodes a lenient JSON string into `A`.
+*
+* Drop-in replacement for `Schema.fromJsonString(schema)` that tolerates
+* trailing commas and comments in the input.
+*/
+const fromLenientJson = (schema) => effect.Schema.String.pipe(effect.Schema.decodeTo(schema, fromLenientJsonString));
+//#endregion
+//#region src/vcs/VcsProcess.ts
+var VcsProcess = class extends effect.Context.Service()("ryco/vcs/VcsProcess") {};
+const DEFAULT_TIMEOUT_MS = 3e4;
+const DEFAULT_MAX_OUTPUT_BYTES = 1e6;
+const OUTPUT_TRUNCATED_MARKER = "\n\n[truncated]";
+function commandLabel(command, args) {
+	return [command, ...args].join(" ");
+}
+function outputDecodeError(input, detail, cause) {
+	return new require_collectUint8StreamText.VcsOutputDecodeError({
+		operation: input.operation,
+		command: commandLabel(input.command, input.args),
+		cwd: input.cwd,
+		detail,
+		cause
+	});
+}
+const collectText = effect.Effect.fn("VcsProcess.collectText")(function* (input) {
+	const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+	return yield* require_collectUint8StreamText.collectUint8StreamText({
+		stream: input.stream,
+		maxBytes: maxOutputBytes,
+		truncatedMarker: input.truncateOutputAtMaxBytes ? OUTPUT_TRUNCATED_MARKER : null
+	});
+});
+const make = effect.Effect.fn("makeVcsProcess")(function* () {
+	const spawner = yield* effect_unstable_process.ChildProcessSpawner.ChildProcessSpawner;
+	const spawn = effect.Effect.fn("VcsProcess.spawn")(function* (input) {
+		const label = commandLabel(input.command, input.args);
+		const child = yield* spawner.spawn(effect_unstable_process.ChildProcess.make(input.command, [...input.args], {
+			cwd: input.cwd,
+			env: {
+				...process.env,
+				...input.env
+			}
+		})).pipe(effect.Effect.mapError((cause) => new require_collectUint8StreamText.VcsProcessSpawnError({
+			operation: input.operation,
+			command: label,
+			cwd: input.cwd,
+			cause
+		})));
+		yield* effect.Effect.addFinalizer(() => child.kill().pipe(effect.Effect.ignore));
+		const mapStreamError = (streamName) => effect.Stream.mapError((cause) => outputDecodeError(input, `failed to read process ${streamName}`, cause));
+		const mapEffectError = (detail) => effect.Effect.mapError((cause) => outputDecodeError(input, detail, cause));
+		const writeStdin = (stdin) => effect.Stream.run(effect.Stream.encodeText(effect.Stream.make(stdin)), child.stdin).pipe(mapEffectError("failed to write process stdin"));
+		return {
+			pid: child.pid,
+			stdin: child.stdin.pipe(effect.Sink.mapError((cause) => outputDecodeError(input, "failed to write process stdin", cause))),
+			stdout: child.stdout.pipe(mapStreamError("stdout")),
+			stderr: child.stderr.pipe(mapStreamError("stderr")),
+			exitCode: child.exitCode.pipe(mapEffectError("failed to read process exit code")),
+			writeStdin
+		};
+	});
+	const withProcess = (input, use) => effect.Effect.scoped(spawn(input).pipe(effect.Effect.flatMap(use)));
+	const run = effect.Effect.fn("VcsProcess.run")(function* (input) {
+		const timeoutMs = input.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+		const maxOutputBytes = input.maxOutputBytes ?? DEFAULT_MAX_OUTPUT_BYTES;
+		const label = commandLabel(input.command, input.args);
+		return yield* effect.Effect.gen(function* () {
+			const [stdout, stderr, exitCode] = yield* withProcess(input, (child) => effect.Effect.all([
+				collectText({
+					operation: input.operation,
+					command: label,
+					cwd: input.cwd,
+					stream: child.stdout,
+					maxOutputBytes,
+					truncateOutputAtMaxBytes: input.truncateOutputAtMaxBytes ?? false
+				}),
+				collectText({
+					operation: input.operation,
+					command: label,
+					cwd: input.cwd,
+					stream: child.stderr,
+					maxOutputBytes,
+					truncateOutputAtMaxBytes: input.truncateOutputAtMaxBytes ?? false
+				}),
+				child.exitCode,
+				input.stdin === void 0 ? effect.Effect.void : child.writeStdin(input.stdin)
+			], { concurrency: "unbounded" })).pipe(effect.Effect.map(([stdout, stderr, exitCode]) => [
+				stdout,
+				stderr,
+				exitCode
+			]));
+			if (!input.allowNonZeroExit && exitCode !== 0) return yield* new require_collectUint8StreamText.VcsProcessExitError({
+				operation: input.operation,
+				command: label,
+				cwd: input.cwd,
+				exitCode,
+				detail: stderr.text.trim() || `${label} exited with code ${exitCode}.`
+			});
+			return {
+				exitCode,
+				stdout: stdout.text,
+				stderr: stderr.text,
+				stdoutTruncated: stdout.truncated,
+				stderrTruncated: stderr.truncated
+			};
+		}).pipe(effect.Effect.scoped, effect.Effect.timeoutOption(effect.Duration.millis(timeoutMs)), effect.Effect.flatMap((result) => effect.Option.match(result, {
+			onSome: effect.Effect.succeed,
+			onNone: () => effect.Effect.fail(new require_collectUint8StreamText.VcsProcessTimeoutError({
+				operation: input.operation,
+				command: label,
+				cwd: input.cwd,
+				timeoutMs
+			}))
+		})));
+	});
+	return VcsProcess.of({
+		withProcess,
+		run
+	});
+});
+const layer = effect.Layer.effect(VcsProcess, make());
+//#endregion
+//#region src/sourceControl/SourceControlProvider.ts
+function parseSourceControlOwnerRef(headSelector) {
+	const match = /^([^:/\s]+):(.+)$/u.exec(headSelector.trim());
+	const owner = match?.[1]?.trim();
+	const refName = match?.[2]?.trim();
+	return owner && refName ? {
+		owner,
+		refName
+	} : void 0;
+}
+function normalizeSourceBranch(headSelector) {
+	return parseSourceControlOwnerRef(headSelector)?.refName ?? headSelector.trim();
+}
+function sourceBranch(input) {
+	return input.source?.refName ?? normalizeSourceBranch(input.headSelector);
+}
+function sourceControlRefFromInput(input) {
+	return input.source ?? parseSourceControlOwnerRef(input.headSelector);
+}
+var SourceControlProvider = class extends effect.Context.Service()("ryco/source-control/SourceControlProvider") {};
+//#endregion
+//#region src/sourceControl/gitHubAuthStatus.ts
+const GitHubAuthStatusAccountSchema = effect.Schema.Struct({
+	state: effect.Schema.String,
+	error: effect.Schema.optional(effect.Schema.String),
+	active: effect.Schema.Boolean,
+	host: effect.Schema.String,
+	login: effect.Schema.String
+});
+const GitHubAuthStatusSchema = effect.Schema.Struct({ hosts: effect.Schema.Record(effect.Schema.String, effect.Schema.Array(GitHubAuthStatusAccountSchema)) });
+const decodeGitHubAuthStatusJson = effect.Schema.decodeUnknownOption(effect.Schema.fromJsonString(GitHubAuthStatusSchema));
+function nonEmptyString(value) {
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function parseGitHubAuthStatus(text) {
+	return effect.Option.match(decodeGitHubAuthStatusJson(text), {
+		onNone: () => ({
+			parsed: false,
+			accounts: []
+		}),
+		onSome: (status) => ({
+			parsed: true,
+			accounts: Object.values(status.hosts).flatMap((accounts) => accounts.flatMap((account) => {
+				const host = nonEmptyString(account.host);
+				const login = nonEmptyString(account.login);
+				if (host === null || login === null) return [];
+				return [{
+					host: host.toLowerCase(),
+					account: login,
+					authenticated: account.state === "success",
+					active: account.active,
+					error: account.error?.trim() || null
+				}];
+			}))
+		})
+	});
+}
+function findAuthenticatedGitHubAccount(accounts) {
+	return accounts.find((account) => account.authenticated && account.active) ?? accounts.find((account) => account.authenticated);
+}
+//#endregion
+//#region src/sourceControl/gitLabAuthStatus.ts
+const HOST_LINE_PATTERN = /^(?:[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?|\[[a-f0-9:.]+\])(?::\d+)?$/iu;
+const LOGGED_IN_PATTERN = /Logged in to .+? as\s+([^\s(]+)/iu;
+function parseGitLabAuthStatusHosts(text) {
+	const hosts = [];
+	let currentHost = null;
+	let currentLines = [];
+	const flush = () => {
+		if (currentHost === null) return;
+		const account = LOGGED_IN_PATTERN.exec(currentLines.join("\n"))?.[1]?.trim() || null;
+		hosts.push({
+			host: currentHost,
+			account,
+			authenticated: account !== null
+		});
+		currentHost = null;
+		currentLines = [];
+	};
+	for (const rawLine of text.split(/\r?\n/)) {
+		const line = rawLine.trim();
+		if (line.length === 0) continue;
+		if (rawLine.length === rawLine.trimStart().length && HOST_LINE_PATTERN.test(line)) {
+			flush();
+			currentHost = line.toLowerCase();
+			continue;
+		}
+		if (currentHost !== null) currentLines.push(line);
+	}
+	flush();
+	return hosts;
+}
+function findAuthenticatedGitLabHost(hosts) {
+	return hosts.find((host) => host.authenticated);
+}
+//#endregion
+//#region src/sourceControl/SourceControlProviderDiscovery.ts
+function firstNonEmptyLine(text) {
+	const line = text.split(/\r?\n/).map((entry) => entry.trim()).find((entry) => entry.length > 0);
+	return line === void 0 ? effect.Option.none() : effect.Option.some(line);
+}
+function detailFromCause(cause) {
+	if (cause instanceof Error && cause.message.trim().length > 0) return effect.Option.some(cause.message.trim());
+	return effect.Option.none();
+}
+function authAccount(account) {
+	const trimmed = account?.trim();
+	return trimmed === void 0 || trimmed.length === 0 ? effect.Option.none() : effect.Option.some(trimmed);
+}
+function authHost(host) {
+	const trimmed = host?.trim();
+	return trimmed === void 0 || trimmed.length === 0 ? effect.Option.none() : effect.Option.some(trimmed);
+}
+function authDetail(detail) {
+	const trimmed = detail?.trim();
+	return trimmed === void 0 || trimmed.length === 0 ? effect.Option.none() : effect.Option.some(trimmed);
+}
+function providerAuth(input) {
+	return {
+		status: input.status,
+		account: authAccount(input.account),
+		host: authHost(input.host),
+		detail: authDetail(input.detail)
+	};
+}
+function unknownAuth(detail) {
+	return providerAuth({
+		status: "unknown",
+		detail
+	});
+}
+function combinedAuthOutput(input) {
+	return [input.stdout, input.stderr].filter((entry) => entry.trim().length > 0).join("\n");
+}
+function sanitizedAuthLines(text) {
+	return text.split(/\r?\n/).map((entry) => entry.trim()).filter((entry) => entry.length > 0).filter((entry) => !/^[-\s]*token(?:\s+scopes?)?:/iu.test(entry));
+}
+function firstSafeAuthLine(text) {
+	return sanitizedAuthLines(text)[0];
+}
+function parseCliHost(text) {
+	return sanitizedAuthLines(text).map((line) => line.replace(/^[^a-z0-9]+/iu, "")).find((line) => /^[a-z0-9][a-z0-9.-]*(?::\d+)?$/iu.test(line));
+}
+function matchFirst(text, patterns) {
+	for (const pattern of patterns) {
+		const value = pattern.exec(text)?.[1]?.trim();
+		if (value && value.length > 0) return value;
+	}
+}
+function isCliRemoteRefinementSpec(spec) {
+	return spec.type === "cli" && spec.refineUnknownRemote !== void 0;
+}
+function probeCli(input) {
+	return input.process.run({
+		operation: "source-control.discovery.probe",
+		command: input.spec.executable,
+		args: input.spec.versionArgs,
+		cwd: input.cwd,
+		timeoutMs: 5e3,
+		maxOutputBytes: 8e3,
+		truncateOutputAtMaxBytes: true
+	}).pipe(effect.Effect.map((result) => ({
+		kind: input.spec.kind,
+		label: input.spec.label,
+		executable: input.spec.executable,
+		status: "available",
+		version: effect.Option.orElse(firstNonEmptyLine(result.stdout), () => firstNonEmptyLine(result.stderr)),
+		installHint: input.spec.installHint,
+		detail: effect.Option.none()
+	})), effect.Effect.catch((cause) => effect.Effect.succeed({
+		kind: input.spec.kind,
+		label: input.spec.label,
+		executable: input.spec.executable,
+		status: "missing",
+		version: effect.Option.none(),
+		installHint: input.spec.installHint,
+		detail: detailFromCause(cause)
+	})));
+}
+function probeSourceControlProvider(input) {
+	if (input.spec.type === "api") return input.spec.probeAuth.pipe(effect.Effect.map((auth) => ({
+		kind: input.spec.kind,
+		label: input.spec.label,
+		status: "available",
+		version: effect.Option.none(),
+		installHint: input.spec.installHint,
+		detail: effect.Option.none(),
+		auth
+	})));
+	const spec = input.spec;
+	return probeCli({
+		spec,
+		process: input.process,
+		cwd: input.cwd
+	}).pipe(effect.Effect.flatMap((item) => {
+		if (item.status !== "available") return effect.Effect.succeed({
+			...item,
+			auth: unknownAuth("Hosting integration command was not found on the server PATH.")
+		});
+		return input.process.run({
+			operation: "source-control.discovery.auth",
+			command: spec.executable,
+			args: spec.authArgs,
+			cwd: input.cwd,
+			allowNonZeroExit: true,
+			timeoutMs: 5e3,
+			maxOutputBytes: 8e3,
+			truncateOutputAtMaxBytes: true
+		}).pipe(effect.Effect.map((result) => ({
+			...item,
+			auth: spec.parseAuth(result)
+		})), effect.Effect.catch((cause) => effect.Effect.succeed({
+			...item,
+			auth: unknownAuth(effect.Option.getOrUndefined(detailFromCause(cause)))
+		})));
+	}));
+}
+const refineUnknownRemoteProvider = effect.Effect.fn("refineUnknownRemoteProvider")(function* (input) {
+	if (input.context === null || input.context.provider.kind !== "unknown") return input.context;
+	const context = input.context;
+	const provider = (yield* effect.Effect.forEach(input.specs.filter(isCliRemoteRefinementSpec), (spec) => input.process.run({
+		operation: "source-control.discovery.refine-unknown-remote",
+		command: spec.executable,
+		args: spec.authArgs,
+		cwd: input.cwd,
+		allowNonZeroExit: true,
+		timeoutMs: 5e3,
+		maxOutputBytes: 8e3,
+		truncateOutputAtMaxBytes: true
+	}).pipe(effect.Effect.map((auth) => spec.refineUnknownRemote({
+		cwd: input.cwd,
+		context,
+		auth
+	})), effect.Effect.catch(() => effect.Effect.succeed(null))))).find((candidate) => candidate !== null);
+	return provider ? {
+		...context,
+		provider
+	} : context;
+});
+//#endregion
+//#region src/sourceControl/SourceControlProviderDiscoveryCatalog.ts
+function parseGitHubAuth(input) {
+	const output = combinedAuthOutput(input);
+	const authStatus = parseGitHubAuthStatus(input.stdout);
+	const authenticatedAccount = findAuthenticatedGitHubAccount(authStatus.accounts);
+	const fallbackHost = parseCliHost(output);
+	if (authenticatedAccount) return providerAuth({
+		status: "authenticated",
+		account: authenticatedAccount.account,
+		host: authenticatedAccount.host
+	});
+	if (authStatus.parsed) {
+		const failedAccount = authStatus.accounts.find((account) => account.active) ?? authStatus.accounts[0];
+		return providerAuth({
+			status: "unauthenticated",
+			host: failedAccount?.host,
+			detail: failedAccount?.error ?? "Run `gh auth login` to authenticate GitHub CLI with an active account."
+		});
+	}
+	if (input.exitCode !== 0) return providerAuth({
+		status: "unauthenticated",
+		host: fallbackHost,
+		detail: firstSafeAuthLine(output) ?? "Run `gh auth login` to authenticate GitHub CLI."
+	});
+	const account = matchFirst(output, [/Logged in to .* account\s+([^\s(]+)/iu, /Logged in to .* as\s+([^\s(]+)/iu]);
+	if (account) return providerAuth({
+		status: "authenticated",
+		account,
+		host: fallbackHost
+	});
+	return providerAuth({
+		status: "unknown",
+		host: fallbackHost,
+		detail: firstSafeAuthLine(output) ?? "GitHub CLI auth status could not be parsed."
+	});
+}
+function parseGitLabAuth(input) {
+	const output = combinedAuthOutput(input);
+	const authenticatedHost = findAuthenticatedGitLabHost(parseGitLabAuthStatusHosts(output));
+	const account = authenticatedHost?.account ?? matchFirst(output, [
+		/Logged in to .* as\s+([^\s(]+)/iu,
+		/Logged in to .* account\s+([^\s(]+)/iu,
+		/account:\s*([^\s(]+)/iu
+	]);
+	const host = authenticatedHost?.host ?? parseCliHost(output);
+	if (account) return providerAuth({
+		status: "authenticated",
+		account,
+		host
+	});
+	if (input.exitCode !== 0) return providerAuth({
+		status: "unauthenticated",
+		host,
+		detail: firstSafeAuthLine(output) ?? "Run `glab auth login` to authenticate GitLab CLI."
+	});
+	return providerAuth({
+		status: "unknown",
+		host,
+		detail: firstSafeAuthLine(output) ?? "GitLab CLI auth status could not be parsed."
+	});
+}
+function normalizeAuthHost(value) {
+	const trimmed = value?.trim().toLowerCase() ?? "";
+	if (trimmed.length === 0) return null;
+	try {
+		return new URL(trimmed).host.toLowerCase();
+	} catch {
+		return trimmed.replace(/^https?:\/\//iu, "").replace(/\/.*$/u, "");
+	}
+}
+function gitLabProviderForHost(host) {
+	return {
+		kind: "gitlab",
+		name: host === "gitlab.com" ? "GitLab" : "GitLab Self-Hosted",
+		baseUrl: `https://${host}`
+	};
+}
+function refineUnknownGitLabRemote(input) {
+	const remoteHost = normalizeAuthHost(input.context.provider.baseUrl) ?? normalizeAuthHost(input.context.provider.name);
+	if (remoteHost === null) return null;
+	const authenticatedHost = parseGitLabAuthStatusHosts(combinedAuthOutput(input.auth)).find((host) => host.authenticated && host.host === remoteHost);
+	return authenticatedHost ? gitLabProviderForHost(authenticatedHost.host) : null;
+}
+function parseAzureAuth(input) {
+	const account = input.stdout.trim().split(/\r?\n/)[0]?.trim();
+	if (input.exitCode !== 0) return providerAuth({
+		status: "unauthenticated",
+		detail: firstSafeAuthLine(combinedAuthOutput(input)) ?? "Run `az login` to authenticate Azure CLI."
+	});
+	if (account && account.length > 0) return providerAuth({
+		status: "authenticated",
+		account,
+		host: "dev.azure.com"
+	});
+	return providerAuth({
+		status: "unknown",
+		host: "dev.azure.com",
+		detail: "Azure CLI account status could not be parsed."
+	});
+}
+const githubDiscovery = {
+	type: "cli",
+	kind: "github",
+	label: "GitHub",
+	executable: "gh",
+	versionArgs: ["--version"],
+	authArgs: [
+		"auth",
+		"status",
+		"--json",
+		"hosts"
+	],
+	parseAuth: parseGitHubAuth,
+	installHint: "Install the GitHub command-line tool (`gh`) via https://cli.github.com/ or your package manager (for example `brew install gh`)."
+};
+const gitlabDiscovery = {
+	type: "cli",
+	kind: "gitlab",
+	label: "GitLab",
+	executable: "glab",
+	versionArgs: ["--version"],
+	authArgs: ["auth", "status"],
+	parseAuth: parseGitLabAuth,
+	refineUnknownRemote: refineUnknownGitLabRemote,
+	installHint: "Install the GitLab command-line tool (`glab`) from https://gitlab.com/gitlab-org/cli or your package manager (for example `brew install glab`)."
+};
+const azureDevOpsDiscovery = {
+	type: "cli",
+	kind: "azure-devops",
+	label: "Azure DevOps",
+	executable: "az",
+	versionArgs: ["--version"],
+	authArgs: [
+		"account",
+		"show",
+		"--query",
+		"user.name",
+		"-o",
+		"tsv"
+	],
+	parseAuth: parseAzureAuth,
+	installHint: "Install the Azure command-line tools (`az`), then enable Azure DevOps support with `az extension add --name azure-devops`."
+};
+function makeBitbucketDiscovery(bitbucket) {
+	return {
+		type: "api",
+		kind: "bitbucket",
+		label: "Bitbucket",
+		installHint: "Save a Bitbucket app password in Settings -> Source Control -> Atlassian, or set RYCO_BITBUCKET_EMAIL and RYCO_BITBUCKET_API_TOKEN on the server.",
+		probeAuth: bitbucket.probeAuth
+	};
+}
+function makeForgejoDiscovery(forgejo) {
+	return {
+		type: "api",
+		kind: "forgejo",
+		label: "Forgejo",
+		installHint: "Authenticate with `fj auth login` on the server and verify with `fj -H codeberg.org whoami`, or set RYCO_FORGEJO_BASE_URL and RYCO_FORGEJO_TOKEN. For unusual fj installs, point Ryco at the token file with RYCO_FORGEJO_CLI_KEYS_FILE.",
+		probeAuth: forgejo.probeAuth
+	};
+}
+//#endregion
+Object.defineProperty(exports, "SourceControlProvider", {
+	enumerable: true,
+	get: function() {
+		return SourceControlProvider;
+	}
+});
+Object.defineProperty(exports, "VcsProcess", {
+	enumerable: true,
+	get: function() {
+		return VcsProcess;
+	}
+});
+Object.defineProperty(exports, "azureDevOpsDiscovery", {
+	enumerable: true,
+	get: function() {
+		return azureDevOpsDiscovery;
+	}
+});
+Object.defineProperty(exports, "decodeJsonResult", {
+	enumerable: true,
+	get: function() {
+		return decodeJsonResult;
+	}
+});
+Object.defineProperty(exports, "detailFromCause", {
+	enumerable: true,
+	get: function() {
+		return detailFromCause;
+	}
+});
+Object.defineProperty(exports, "firstNonEmptyLine", {
+	enumerable: true,
+	get: function() {
+		return firstNonEmptyLine;
+	}
+});
+Object.defineProperty(exports, "formatSchemaError", {
+	enumerable: true,
+	get: function() {
+		return formatSchemaError;
+	}
+});
+Object.defineProperty(exports, "fromLenientJson", {
+	enumerable: true,
+	get: function() {
+		return fromLenientJson;
+	}
+});
+Object.defineProperty(exports, "githubDiscovery", {
+	enumerable: true,
+	get: function() {
+		return githubDiscovery;
+	}
+});
+Object.defineProperty(exports, "gitlabDiscovery", {
+	enumerable: true,
+	get: function() {
+		return gitlabDiscovery;
+	}
+});
+Object.defineProperty(exports, "layer", {
+	enumerable: true,
+	get: function() {
+		return layer;
+	}
+});
+Object.defineProperty(exports, "makeBitbucketDiscovery", {
+	enumerable: true,
+	get: function() {
+		return makeBitbucketDiscovery;
+	}
+});
+Object.defineProperty(exports, "makeForgejoDiscovery", {
+	enumerable: true,
+	get: function() {
+		return makeForgejoDiscovery;
+	}
+});
+Object.defineProperty(exports, "parseSourceControlOwnerRef", {
+	enumerable: true,
+	get: function() {
+		return parseSourceControlOwnerRef;
+	}
+});
+Object.defineProperty(exports, "probeSourceControlProvider", {
+	enumerable: true,
+	get: function() {
+		return probeSourceControlProvider;
+	}
+});
+Object.defineProperty(exports, "refineUnknownRemoteProvider", {
+	enumerable: true,
+	get: function() {
+		return refineUnknownRemoteProvider;
+	}
+});
+Object.defineProperty(exports, "sourceBranch", {
+	enumerable: true,
+	get: function() {
+		return sourceBranch;
+	}
+});
+Object.defineProperty(exports, "sourceControlRefFromInput", {
+	enumerable: true,
+	get: function() {
+		return sourceControlRefFromInput;
+	}
+});