fireflyy 3.0.11 → 4.0.0-dev.352994a

package/dist/git.service-DarjfyXF.js

@@ -0,0 +1,587 @@
+import { t as logger } from "./main.js";
+import { i as FireflyOkAsync, m as failedError, o as failedErrAsync } from "./result.constructors-C9M1MP3_.js";
+import { t as withDryRun } from "./dry-run-BfYCtldz.js";
+import { ResultAsync } from "neverthrow";
+import { z } from "zod";
+
+//#region src/infrastructure/executors/git-command.executor.ts
+/**
+* Git commands that modify repository state.
+* These commands are skipped during dry-run mode.
+*/
+const SIDE_EFFECT_COMMANDS = new Set([
+	"add",
+	"am",
+	"apply",
+	"branch",
+	"checkout",
+	"cherry-pick",
+	"clean",
+	"commit",
+	"fetch",
+	"merge",
+	"mv",
+	"pull",
+	"push",
+	"rebase",
+	"reset",
+	"restore",
+	"revert",
+	"rm",
+	"stash",
+	"switch",
+	"tag",
+	"worktree"
+]);
+/**
+* Git commands that benefit from streaming execution.
+* These commands often produce large outputs that should be processed incrementally.
+*/
+const STREAMING_COMMANDS = new Set([
+	"rev-list",
+	"log",
+	"show",
+	"diff",
+	"blame",
+	"cat-file"
+]);
+const gitArgsSchema = z.array(z.string().min(1));
+/**
+* Determines if the given arguments contain commands that modify repository state.
+*
+* @param args - Git command arguments to check
+* @returns `true` if any argument is a side-effect command
+*/
+function hasSideEffects(args) {
+	if (args.length === 0) return false;
+	return args.map((token) => token.toLowerCase()).some((token) => SIDE_EFFECT_COMMANDS.has(token));
+}
+/**
+* Determines if the given arguments should use streaming execution.
+*
+* @param args - Git command arguments to check
+* @returns `true` if streaming execution is recommended
+*/
+function shouldUseStreaming(args) {
+	if (args.length === 0) return false;
+	return args.map((token) => token.toLowerCase()).some((token) => STREAMING_COMMANDS.has(token));
+}
+/**
+* Reads a process stdout stream into a string with abort support.
+*
+* @param args - Git command arguments
+* @param spawnOptions - Spawn configuration for the Git process
+* @param signal - Optional abort signal for cancellation
+* @returns Promise resolving to the complete stdout output
+*/
+function streamToString(args, spawnOptions, signal) {
+	return new Promise((resolve, reject) => {
+		const proc = Bun.spawn(["git", ...args], spawnOptions);
+		if (signal) {
+			const onAbort = () => {
+				proc.kill();
+				reject(new Error("Git command aborted", { cause: signal.reason }));
+			};
+			if (signal.aborted) {
+				onAbort();
+				return;
+			}
+			signal.addEventListener("abort", onAbort, { once: true });
+		}
+		const chunks = [];
+		const reader = proc.stdout.getReader();
+		const decoder = new TextDecoder();
+		const readChunks = () => {
+			if (signal?.aborted) {
+				reader.cancel();
+				return;
+			}
+			reader.read().then((readResult) => {
+				if (readResult.done) {
+					const finalChunk = decoder.decode();
+					if (finalChunk) chunks.push(finalChunk);
+					proc.exited.then(() => {
+						if (proc.exitCode !== 0) new Response(proc.stderr).text().then((stderrText) => {
+							const errorMessage = `Git process exited with code ${proc.exitCode}: ${stderrText}`;
+							reject(new Error(errorMessage));
+						});
+						else resolve(chunks.join(""));
+					});
+				} else {
+					const decodedChunk = decoder.decode(readResult.value, { stream: true });
+					chunks.push(decodedChunk);
+					readChunks();
+				}
+			});
+		};
+		readChunks();
+	});
+}
+/**
+* Executes a Git command using buffered output collection.
+* Waits for the process to complete before returning the full output.
+*
+* @param args - Git command arguments
+* @param spawnOptions - Spawn configuration for the Git process
+* @param commandStr - Full command string for error messages
+* @param signal - Optional abort signal for cancellation
+* @returns FireflyAsyncResult containing stdout output or error
+*/
+function executeGitCommandBuffered(args, spawnOptions, commandStr, signal) {
+	const proc = Bun.spawn(["git", ...args], spawnOptions);
+	const outputPromise = new Response(proc.stdout).text();
+	const exitPromise = proc.exited;
+	const abortPromise = signal ? new Promise((_, reject) => {
+		const onAbort = () => {
+			proc.kill();
+			reject(new Error(`Git command aborted: ${commandStr}`, { cause: signal.reason }));
+		};
+		if (signal.aborted) onAbort();
+		else signal.addEventListener("abort", onAbort, { once: true });
+	}) : null;
+	const executionPromise = Promise.all([outputPromise, exitPromise]).then(([output]) => {
+		if (proc.exitCode !== 0) return new Response(proc.stderr).text().then((stderrText) => {
+			const errorMessage = `Git process exited with code ${proc.exitCode}: ${stderrText}`;
+			return Promise.reject(new Error(errorMessage));
+		});
+		return output;
+	});
+	const racePromise = abortPromise ? Promise.race([executionPromise, abortPromise]) : executionPromise;
+	return ResultAsync.fromPromise(racePromise, (error) => failedError({
+		message: `Git command failed: ${commandStr}`,
+		details: error
+	}));
+}
+/**
+* Executes a Git command using streaming output collection.
+*
+* @param args - Git command arguments
+* @param spawnOptions - Spawn configuration for the Git process
+* @param commandStr - Full command string for error messages
+* @param signal - Optional abort signal for cancellation
+* @returns FireflyAsyncResult containing stdout output or error
+*/
+function executeGitCommandStreaming(args, spawnOptions, commandStr, signal) {
+	return ResultAsync.fromPromise(streamToString(args, spawnOptions, signal), (error) => failedError({
+		message: `Git command failed: ${commandStr}`,
+		details: error
+	}));
+}
+/**
+* Executes a Git command with comprehensive error handling and cancellation support.
+*
+* @example
+* ```ts
+* // Simple command
+* const result = await executeGitCommand(["status", "--porcelain"]);
+*
+* // With timeout
+* const result = await executeGitCommand(["log", "--oneline"], { timeoutMs: 5000 });
+*
+* // With abort signal
+* const controller = new AbortController();
+* const result = await executeGitCommand(["fetch", "--all"], { signal: controller.signal });
+* ```
+*
+* @param args - Git command arguments (e.g., ["status", "--porcelain"])
+* @param options - Execution options for dry-run, timeout, etc.
+* @returns FireflyAsyncResult containing stdout output or FireflyError
+*/
+function executeGitCommand(args, options = {}) {
+	const resolvedOptions = {
+		verbose: true,
+		...options
+	};
+	const parseResult = gitArgsSchema.safeParse(args);
+	if (!parseResult.success) return failedErrAsync({
+		message: "Invalid git arguments",
+		details: parseResult.error
+	});
+	const validatedArgs = parseResult.data;
+	const commandStr = `git ${validatedArgs.join(" ")}`;
+	const signal = resolvedOptions.signal ?? (resolvedOptions.timeoutMs ? AbortSignal.timeout(resolvedOptions.timeoutMs) : void 0);
+	if (signal?.aborted) return failedErrAsync({
+		message: `Git command aborted before execution: ${commandStr}`,
+		details: signal.reason
+	});
+	const useStreaming = shouldUseStreaming(validatedArgs) && !resolvedOptions.forceBuffered;
+	const executionMode = useStreaming ? "streaming" : "buffered";
+	if (resolvedOptions.verbose) logger.verbose(`GitCommandExecutor: Executing git command (${executionMode}): ${commandStr}`);
+	if (resolvedOptions.dryRun && hasSideEffects(validatedArgs)) {
+		const dryRunMessage = `Dry run: Skipping ${commandStr}`;
+		return withDryRun(resolvedOptions, dryRunMessage, () => FireflyOkAsync(dryRunMessage), dryRunMessage);
+	}
+	const spawnOptions = {
+		cwd: resolvedOptions.cwd ?? process.cwd(),
+		stdout: "pipe",
+		stderr: "pipe"
+	};
+	if (useStreaming) return executeGitCommandStreaming(validatedArgs, spawnOptions, commandStr, signal);
+	return executeGitCommandBuffered(validatedArgs, spawnOptions, commandStr, signal);
+}
+
+//#endregion
+//#region src/services/implementations/git.service.ts
+const CURRENT_BRANCH_MARKER_REGEX = /^\*\s*/;
+const REMOTES_PREFIX_REGEX = /^remotes\//;
+/**
+* Default implementation of the git service.
+*/
+var DefaultGitService = class {
+	/**
+	* The working directory where git commands are executed.
+	*/
+	cwd;
+	/**
+	* Creates a new git service.
+	* @param cwd - The working directory for git operations
+	*/
+	constructor(cwd) {
+		this.cwd = cwd;
+	}
+	/**
+	* Executes a git command with the configured working directory
+	*
+	* @param args - Git command arguments
+	* @param options - Execution options
+	* @returns Command output or error
+	*/
+	git(args, options) {
+		return executeGitCommand(args, {
+			cwd: this.cwd,
+			dryRun: options?.dryRun,
+			verbose: options?.verbose ?? true
+		});
+	}
+	isInsideRepository() {
+		return this.git(["rev-parse", "--is-inside-work-tree"]).map(() => true).orElse(() => FireflyOkAsync(false));
+	}
+	getRepositoryRoot() {
+		return this.git(["rev-parse", "--show-toplevel"]).map((output) => output.trim());
+	}
+	getRemoteUrl(remote) {
+		const remoteName = remote ?? "origin";
+		return this.git([
+			"remote",
+			"get-url",
+			remoteName
+		]).map((output) => output.trim());
+	}
+	getStatus() {
+		return this.git(["status", "--porcelain"]).map((output) => {
+			const lines = output.split("\n").filter((line) => line.length > 0);
+			let hasStaged = false;
+			let hasUnstaged = false;
+			let hasUntracked = false;
+			for (const line of lines) {
+				const index = line[0];
+				const workTree = line[1];
+				if (index === "?") hasUntracked = true;
+				else if (index !== " " && index !== "?") hasStaged = true;
+				if (workTree !== " " && workTree !== "?") hasUnstaged = true;
+			}
+			return {
+				hasStaged,
+				hasUnstaged,
+				hasUntracked,
+				isClean: lines.length === 0
+			};
+		});
+	}
+	isWorkingTreeClean() {
+		return this.getStatus().map((status) => status.isClean);
+	}
+	/**
+	* Parses git status porcelain output into structured file status objects.
+	*
+	* @param output - The raw output from `git status --porcelain`
+	* @returns Array of GitFileStatus objects
+	*/
+	parseStatusOutput(output) {
+		return output.split("\n").filter((line) => line.length >= 3).map((line) => {
+			const indexStatus = line[0] ?? " ";
+			const workTreeStatus = line[1] ?? " ";
+			return {
+				path: line.slice(3).trim(),
+				indexStatus,
+				workTreeStatus
+			};
+		});
+	}
+	getFiles(filter) {
+		const includeStaged = filter?.staged ?? true;
+		const includeUnstaged = filter?.unstaged ?? true;
+		return this.git(["status", "--porcelain"]).map((output) => {
+			return this.parseStatusOutput(output).filter((file) => {
+				const isStaged = file.indexStatus !== " " && file.indexStatus !== "?";
+				const isUnstaged = file.workTreeStatus !== " " && file.workTreeStatus !== "?";
+				if (includeStaged && includeUnstaged) return isStaged || isUnstaged;
+				if (includeStaged) return isStaged;
+				if (includeUnstaged) return isUnstaged;
+				return false;
+			});
+		});
+	}
+	getFileNames(filter) {
+		return this.getFiles(filter).map((files) => files.map((file) => file.path));
+	}
+	getCurrentBranch() {
+		return this.git([
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		]).map((output) => output.trim());
+	}
+	hasBranch(branch) {
+		return this.git([
+			"rev-parse",
+			"--verify",
+			branch
+		]).map(() => true).orElse(() => FireflyOkAsync(false));
+	}
+	parseBranchLine(line) {
+		const isCurrent = line.startsWith("*");
+		const isRemote = line.includes("remotes/");
+		let branchName = line.replace(CURRENT_BRANCH_MARKER_REGEX, "").trim();
+		if (isRemote) branchName = branchName.replace(REMOTES_PREFIX_REGEX, "");
+		return {
+			name: branchName,
+			isCurrent,
+			isRemote
+		};
+	}
+	listBranches(includeRemote) {
+		const args = ["branch"];
+		if (includeRemote) args.push("-a");
+		return this.git(args).map((output) => {
+			return output.split("\n").filter((line) => line.trim().length > 0).map((line) => this.parseBranchLine(line));
+		});
+	}
+	createCommit(message, options) {
+		if (options?.dryRun) {
+			logger.verbose("GitService: Dry run, skipping commit");
+			return FireflyOkAsync({ sha: "dry-run-sha" });
+		}
+		const args = [
+			"commit",
+			"-m",
+			message
+		];
+		if (options?.sign) args.push("-S");
+		if (options?.allowEmpty) args.push("--allow-empty");
+		if (options?.noVerify) args.push("--no-verify");
+		if (options?.paths && options.paths.length > 0) args.push("--", ...options.paths);
+		return this.git(args).andThen(() => this.git(["rev-parse", "HEAD"]).map((sha) => ({ sha: sha.trim().substring(0, 7) })));
+	}
+	getCommitHashesSince(since) {
+		const args = since ? ["rev-list", `${since}..HEAD`] : ["rev-list", "HEAD"];
+		return this.git(args).map((output) => output.trim().split("\n").map((line) => line.trim()).filter((line) => line.length > 0));
+	}
+	getCommitDetails(hash) {
+		const format = [
+			"hash:%H",
+			"date:%ci",
+			"author:%an <%ae>",
+			"subject:%s",
+			"body:%b",
+			"notes:%N"
+		].join("%n");
+		return this.git([
+			"show",
+			"--no-patch",
+			`--format=${format}`,
+			hash
+		]);
+	}
+	getUnpushedCommits() {
+		return this.getCurrentBranch().andThen((branch) => {
+			const upstream = `origin/${branch}`;
+			return this.git([
+				"rev-list",
+				"--count",
+				`${upstream}..HEAD`
+			]).map((output) => {
+				const count = Number.parseInt(output.trim(), 10) || 0;
+				return {
+					hasUnpushed: count > 0,
+					count
+				};
+			}).orElse(() => {
+				return this.git([
+					"rev-list",
+					"--count",
+					"HEAD"
+				]).map((output) => {
+					const count = Number.parseInt(output.trim(), 10) || 0;
+					return {
+						hasUnpushed: count > 0,
+						count
+					};
+				}).orElse(() => FireflyOkAsync({
+					hasUnpushed: false,
+					count: 0
+				}));
+			});
+		});
+	}
+	createTag(name, options) {
+		if (options?.dryRun) {
+			logger.verbose(`GitService: Dry run, skipping tag creation: ${name}`);
+			return FireflyOkAsync(void 0);
+		}
+		const args = ["tag"];
+		if (options?.message) args.push("-a", name, "-m", options.message);
+		else args.push(name);
+		if (options?.sign) args.push("-s");
+		return this.git(args).map(() => void 0);
+	}
+	deleteTag(name, options) {
+		const scope = options?.scope ?? "local";
+		const remote = options?.remote ?? "origin";
+		if (options?.dryRun) {
+			logger.verbose(`GitService: Dry run, skipping tag deletion (${scope}): ${name}`);
+			return FireflyOkAsync(void 0);
+		}
+		if (scope === "local") return this.git([
+			"tag",
+			"-d",
+			name
+		]).map(() => void 0);
+		if (scope === "remote") return this.git([
+			"push",
+			remote,
+			`:refs/tags/${name}`
+		]).map(() => void 0);
+		return this.git([
+			"tag",
+			"-d",
+			name
+		]).andThen(() => this.git([
+			"push",
+			remote,
+			`:refs/tags/${name}`
+		])).map(() => void 0);
+	}
+	hasTag(name) {
+		return this.git([
+			"tag",
+			"--list",
+			name
+		]).map((output) => output.trim() === name);
+	}
+	hasAnyTags() {
+		return this.getLatestTag().map((tag) => tag !== null);
+	}
+	listTags() {
+		return this.git(["tag", "--list"]).map((output) => output.split("\n").map((tag) => tag.trim()).filter((tag) => tag.length > 0));
+	}
+	getLatestTag() {
+		return this.git([
+			"describe",
+			"--tags",
+			"--abbrev=0"
+		]).map((output) => {
+			return output.trim() || null;
+		}).orElse((error) => {
+			if (error.message.includes("No names found") || error.message.includes("fatal")) return FireflyOkAsync(null);
+			return FireflyOkAsync(null);
+		});
+	}
+	getTagMessage(name) {
+		return this.git([
+			"tag",
+			"-l",
+			"--format=%(contents)",
+			name
+		]).map((output) => {
+			return output.trim() || null;
+		}).orElse(() => FireflyOkAsync(null));
+	}
+	stage(paths) {
+		const pathArray = Array.isArray(paths) ? paths : [paths];
+		return this.git(["add", ...pathArray]).map(() => void 0);
+	}
+	unstage(paths) {
+		const pathArray = Array.isArray(paths) ? paths : [paths];
+		return this.git([
+			"reset",
+			"HEAD",
+			"--",
+			...pathArray
+		]).map(() => void 0);
+	}
+	push(options) {
+		if (options?.dryRun) {
+			logger.verbose("GitService: Dry run, skipping push");
+			return FireflyOkAsync(void 0);
+		}
+		const args = ["push"];
+		const remote = options?.remote ?? "origin";
+		args.push(remote);
+		if (options?.branch) args.push(options.branch);
+		if (options?.tags) args.push("--tags");
+		if (options?.followTags) args.push("--follow-tags");
+		return this.git(args).map(() => void 0);
+	}
+	/**
+	* Gets the upstream remote name for the current branch.
+	* @returns The remote name or null if no upstream is configured.
+	*/
+	getUpstreamRemote() {
+		return this.git([
+			"rev-parse",
+			"--abbrev-ref",
+			"--symbolic-full-name",
+			"@{upstream}"
+		]).map((output) => {
+			const upstream = output.trim();
+			const slashIndex = upstream.indexOf("/");
+			if (slashIndex > 0) return upstream.substring(0, slashIndex);
+			return null;
+		}).orElse(() => FireflyOkAsync(null));
+	}
+	/**
+	* Lists all configured remotes.
+	* @returns Array of remote names.
+	*/
+	listRemotes() {
+		return this.git(["remote"]).map((output) => output.split("\n").map((remote) => remote.trim()).filter((remote) => remote.length > 0));
+	}
+	inferRepositoryUrl() {
+		return this.getUpstreamRemote().andThen((upstreamRemote) => {
+			if (upstreamRemote) {
+				logger.verbose(`GitService: Inferring repository URL from upstream remote: ${upstreamRemote}`);
+				return this.getRemoteUrl(upstreamRemote).map((url) => url).orElse(() => this.tryOriginOrFirstRemote());
+			}
+			return this.tryOriginOrFirstRemote();
+		});
+	}
+	/**
+	* Tries to get the repository URL from 'origin' or the first available remote.
+	*/
+	tryOriginOrFirstRemote() {
+		return this.getRemoteUrl("origin").map((url) => {
+			logger.verbose("GitService: Inferring repository URL from origin remote");
+			return url;
+		}).orElse(() => {
+			return this.listRemotes().andThen((remotes) => {
+				if (remotes.length === 0) {
+					logger.verbose("GitService: No remotes configured, cannot infer repository URL");
+					return FireflyOkAsync(null);
+				}
+				const firstRemote = remotes[0];
+				logger.verbose(`GitService: Inferring repository URL from first remote: ${firstRemote}`);
+				return this.getRemoteUrl(firstRemote).map((url) => url).orElse(() => FireflyOkAsync(null));
+			});
+		});
+	}
+};
+/**
+* Creates a git service instance.
+*/
+function createGitService(cwd) {
+	return new DefaultGitService(cwd);
+}
+
+//#endregion
+export { createGitService };

package/dist/index.d.ts

@@ -1,19 +1,17 @@
-import z$1, { z } from "zod";
+import z from "zod";
 
-//#region src/modules/configuration/schema/config-base.schema.d.ts
-declare const BaseConfigSchema: z$1.ZodObject<{
-  repository: z$1.ZodDefault<z$1.ZodUnion<[z$1.ZodString, z$1.ZodLiteral<"">]>>;
-  verbose: z$1.ZodDefault<z$1.ZodBoolean>;
-  dryRun: z$1.ZodDefault<z$1.ZodBoolean>;
-  branch: z$1.ZodOptional<z$1.ZodString>;
-}, z$1.core.$strip>;
-//#endregion
-//#region src/modules/configuration/config-schema.provider.d.ts
-declare const schemas: {
-  readonly release: z.ZodObject<{
+//#region src/cli/config/config.schema.d.ts
+
+/**
+ * Complete Firefly configuration schema.
+ * Combines global options with command-specific configuration sections.
+ */
+declare const FireflyConfigSchema: z.ZodObject<{
+  release: z.ZodOptional<z.ZodObject<{
     name: z.ZodOptional<z.ZodString>;
     scope: z.ZodOptional<z.ZodString>;
     base: z.ZodDefault<z.ZodString>;
+    branch: z.ZodOptional<z.ZodString>;
     changelogPath: z.ZodDefault<z.ZodString>;
     bumpStrategy: z.ZodDefault<z.ZodUnion<[z.ZodEnum<{
       auto: "auto";
@@ -29,7 +27,7 @@ declare const schemas: {
       prepatch: "prepatch";
       graduate: "graduate";
     }>>;
-    preReleaseId: z.ZodDefault<z.ZodString>;
+    preReleaseId: z.ZodOptional<z.ZodString>;
     preReleaseBase: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodLiteral<"0">, z.ZodLiteral<"1">]>>;
     releaseNotes: z.ZodDefault<z.ZodString>;
     commitMessage: z.ZodDefault<z.ZodString>;
@@ -44,16 +42,38 @@ declare const schemas: {
     releaseLatest: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
     releasePreRelease: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
     releaseDraft: z.ZodDefault<z.ZodCoercedBoolean<unknown>>;
-  }, z.core.$strip>;
-};
-type BaseConfig = z.infer<typeof BaseConfigSchema>;
-type CommandName = keyof typeof schemas;
-type CommandConfigMap = { [K in keyof typeof schemas]: z.infer<(typeof schemas)[K]> };
-type FinalConfigFor<C extends CommandName> = BaseConfig & CommandConfigMap[C];
-type _FireflyConfig = FinalConfigFor<CommandName>;
+  }, z.core.$strip>>;
+  cwd: z.ZodOptional<z.ZodString>;
+  dryRun: z.ZodOptional<z.ZodBoolean>;
+  verbose: z.ZodOptional<z.ZodBoolean>;
+  enableRollback: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * TypeScript type for Firefly configuration.
+ * Use this type when you need to reference the configuration shape without runtime validation.
+ */
+type FireflyConfig = z.infer<typeof FireflyConfigSchema>;
 //#endregion
-//#region src/platform/config/index.d.ts
-type FireflyConfig = Partial<_FireflyConfig>;
+//#region src/config/index.d.ts
+/**
+ * Helper function to define a type-safe Firefly configuration.
+ *
+ * Provides IntelliSense autocompletion and type checking for config files.
+ *
+ * @param options - The configuration options
+ * @returns The same options (identity function for type inference)
+ *
+ * @example
+ * ```ts
+ * export default defineConfig({
+ *     verbose: true,
+ *     release: {
+ *         bumpStrategy: "conventional",
+ *         releaseType: "github",
+ *     },
+ * });
+ * ```
+ */
 declare function defineConfig<T extends FireflyConfig>(options: T): T;
 //#endregion
-export { FireflyConfig, defineConfig };
+export { defineConfig };

package/dist/index.js

@@ -1,4 +1,23 @@
-//#region src/platform/config/index.ts
+//#region src/config/index.ts
+/**
+* Helper function to define a type-safe Firefly configuration.
+*
+* Provides IntelliSense autocompletion and type checking for config files.
+*
+* @param options - The configuration options
+* @returns The same options (identity function for type inference)
+*
+* @example
+* ```ts
+* export default defineConfig({
+*     verbose: true,
+*     release: {
+*         bumpStrategy: "conventional",
+*         releaseType: "github",
+*     },
+* });
+* ```
+*/
 function defineConfig(options) {
 	return options;
 }