@optique/git 0.9.0-dev.1

package/dist/index.cjs

@@ -0,0 +1,553 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __optique_core_message = __toESM(require("@optique/core/message"));
+const __optique_core_nonempty = __toESM(require("@optique/core/nonempty"));
+const isomorphic_git = __toESM(require("isomorphic-git"));
+const node_process = __toESM(require("node:process"));
+
+//#region src/index.ts
+const METAVAR_BRANCH = "BRANCH";
+const METAVAR_TAG = "TAG";
+const METAVAR_REMOTE = "REMOTE";
+let defaultFs = null;
+let fsLoading = null;
+async function getDefaultFs() {
+	if (defaultFs) return await defaultFs;
+	if (fsLoading) return await fsLoading;
+	fsLoading = (async () => {
+		const nodeFs = await import("node:fs/promises");
+		const { TextDecoder } = await import("node:util");
+		const decoder = new TextDecoder();
+		defaultFs = {
+			async readFile(path) {
+				const data = await nodeFs.readFile(path);
+				if (path.endsWith("/index") || path.endsWith(".idx")) return data;
+				return decoder.decode(data);
+			},
+			async writeFile(path, data) {
+				await nodeFs.writeFile(path, data);
+			},
+			async mkdir(path, options) {
+				await nodeFs.mkdir(path, options);
+			},
+			async rmdir(path, options) {
+				await nodeFs.rmdir(path, options);
+			},
+			async unlink(path) {
+				await nodeFs.unlink(path);
+			},
+			async readdir(path) {
+				const entries = await nodeFs.readdir(path, { withFileTypes: false });
+				return entries.filter((e) => typeof e === "string");
+			},
+			async lstat(path) {
+				return await nodeFs.lstat(path);
+			},
+			async stat(path) {
+				return await nodeFs.stat(path);
+			},
+			async readlink(path) {
+				return await nodeFs.readlink(path);
+			},
+			async symlink(target, path) {
+				await nodeFs.symlink(target, path, "file");
+			},
+			async chmod(path, mode) {
+				await nodeFs.chmod(path, mode);
+			},
+			async chown(path, uid, gid) {
+				await nodeFs.chown(path, uid, gid);
+			},
+			async rename(oldPath, newPath) {
+				await nodeFs.rename(oldPath, newPath);
+			},
+			async copyFile(srcPath, destPath) {
+				await nodeFs.copyFile(srcPath, destPath);
+			},
+			async exists(path) {
+				try {
+					await nodeFs.stat(path);
+					return true;
+				} catch {
+					return false;
+				}
+			}
+		};
+		return defaultFs;
+	})();
+	return fsLoading;
+}
+function createAsyncValueParser(options, metavar, parseFn, suggestFn) {
+	return {
+		$mode: "async",
+		metavar,
+		async parse(input) {
+			const fs = options?.fs ?? await getDefaultFs();
+			const dir = options?.dir ?? (typeof node_process.default !== "undefined" ? node_process.default.cwd() : ".");
+			(0, __optique_core_nonempty.ensureNonEmptyString)(metavar);
+			return parseFn(fs, dir, input);
+		},
+		format(value) {
+			return value;
+		},
+		async *suggest(prefix) {
+			const fs = options?.fs ?? await getDefaultFs();
+			const dir = options?.dir ?? (typeof node_process.default !== "undefined" ? node_process.default.cwd() : ".");
+			if (suggestFn) yield* suggestFn(fs, dir, prefix);
+		}
+	};
+}
+/**
+* Creates a value parser that validates local branch names.
+*
+* This parser uses isomorphic-git to verify that the provided input
+* matches an existing branch in the repository.
+*
+* @param options Configuration options for the parser.
+* @returns A value parser that accepts existing branch names.
+* @since 0.9.0
+*
+* @example
+* ~~~~ typescript
+* import { gitBranch } from "@optique/git";
+* import { argument } from "@optique/core/primitives";
+*
+* const parser = argument(gitBranch());
+* ~~~~
+*/
+function gitBranch(options) {
+	const metavar = options?.metavar ?? METAVAR_BRANCH;
+	return createAsyncValueParser(options, metavar, async (fs, dir, input) => {
+		try {
+			const branches = await isomorphic_git.listBranches({
+				fs,
+				dir
+			});
+			if (branches.includes(input)) return {
+				success: true,
+				value: input
+			};
+			return {
+				success: false,
+				error: __optique_core_message.message`Branch ${(0, __optique_core_message.text)(input)} does not exist. Available branches: ${branches.join(", ")}`
+			};
+		} catch {
+			return {
+				success: false,
+				error: __optique_core_message.message`Failed to list branches. Ensure ${(0, __optique_core_message.text)(dir)} is a valid git repository.`
+			};
+		}
+	}, async function* suggestBranch(fs, dir, prefix) {
+		try {
+			const branches = await isomorphic_git.listBranches({
+				fs,
+				dir
+			});
+			for (const branch of branches) if (branch.startsWith(prefix)) yield {
+				kind: "literal",
+				text: branch
+			};
+		} catch {}
+	});
+}
+/**
+* Creates a value parser that validates remote branch names.
+*
+* This parser uses isomorphic-git to verify that the provided input
+* matches an existing branch on the specified remote.
+*
+* @param remote The remote name to validate against.
+* @param options Configuration options for the parser.
+* @returns A value parser that accepts existing remote branch names.
+* @since 0.9.0
+*
+* @example
+* ~~~~ typescript
+* import { gitRemoteBranch } from "@optique/git";
+* import { option } from "@optique/core/primitives";
+*
+* const parser = option("-b", "--branch", gitRemoteBranch("origin"));
+* ~~~~
+*/
+function gitRemoteBranch(remote, options) {
+	const metavar = options?.metavar ?? METAVAR_BRANCH;
+	return createAsyncValueParser(options, metavar, async (fs, dir, input) => {
+		try {
+			const branches = await isomorphic_git.listBranches({
+				fs,
+				dir,
+				remote
+			});
+			if (branches.includes(input)) return {
+				success: true,
+				value: input
+			};
+			return {
+				success: false,
+				error: __optique_core_message.message`Remote branch ${(0, __optique_core_message.text)(input)} does not exist on remote ${(0, __optique_core_message.text)(remote)}. Available branches: ${branches.join(", ")}`
+			};
+		} catch {
+			return {
+				success: false,
+				error: __optique_core_message.message`Failed to list remote branches. Ensure remote ${(0, __optique_core_message.text)(remote)} exists.`
+			};
+		}
+	}, async function* suggestRemoteBranch(fs, dir, prefix) {
+		try {
+			const branches = await isomorphic_git.listBranches({
+				fs,
+				dir,
+				remote
+			});
+			for (const branch of branches) if (branch.startsWith(prefix)) yield {
+				kind: "literal",
+				text: branch
+			};
+		} catch {}
+	});
+}
+/**
+* Creates a value parser that validates tag names.
+*
+* This parser uses isomorphic-git to verify that the provided input
+* matches an existing tag in the repository.
+*
+* @param options Configuration options for the parser.
+* @returns A value parser that accepts existing tag names.
+* @since 0.9.0
+*
+* @example
+* ~~~~ typescript
+* import { gitTag } from "@optique/git";
+* import { option } from "@optique/core/primitives";
+*
+* const parser = option("-t", "--tag", gitTag());
+* ~~~~
+*/
+function gitTag(options) {
+	const metavar = options?.metavar ?? METAVAR_TAG;
+	return createAsyncValueParser(options, metavar, async (fs, dir, input) => {
+		try {
+			const tags = await isomorphic_git.listTags({
+				fs,
+				dir
+			});
+			if (tags.includes(input)) return {
+				success: true,
+				value: input
+			};
+			return {
+				success: false,
+				error: __optique_core_message.message`Tag ${(0, __optique_core_message.text)(input)} does not exist. Available tags: ${tags.join(", ")}`
+			};
+		} catch {
+			return {
+				success: false,
+				error: __optique_core_message.message`Failed to list tags. Ensure ${(0, __optique_core_message.text)(dir)} is a valid git repository.`
+			};
+		}
+	}, async function* suggestTag(fs, dir, prefix) {
+		try {
+			const tags = await isomorphic_git.listTags({
+				fs,
+				dir
+			});
+			for (const tag of tags) if (tag.startsWith(prefix)) yield {
+				kind: "literal",
+				text: tag
+			};
+		} catch {}
+	});
+}
+/**
+* Creates a value parser that validates remote names.
+*
+* This parser uses isomorphic-git to verify that the provided input
+* matches an existing remote in the repository.
+*
+* @param options Configuration options for the parser.
+* @returns A value parser that accepts existing remote names.
+* @since 0.9.0
+*
+* @example
+* ~~~~ typescript
+* import { gitRemote } from "@optique/git";
+* import { option } from "@optique/core/primitives";
+*
+* const parser = option("-r", "--remote", gitRemote());
+* ~~~~
+*/
+function gitRemote(options) {
+	const metavar = options?.metavar ?? METAVAR_REMOTE;
+	return createAsyncValueParser(options, metavar, async (fs, dir, input) => {
+		try {
+			const remotes = await isomorphic_git.listRemotes({
+				fs,
+				dir
+			});
+			const remoteNames = [];
+			for (const r of remotes) if ("remote" in r && typeof r.remote === "string") remoteNames.push(r.remote);
+			if (remoteNames.includes(input)) return {
+				success: true,
+				value: input
+			};
+			return {
+				success: false,
+				error: __optique_core_message.message`Remote ${(0, __optique_core_message.text)(input)} does not exist. Available remotes: ${remoteNames.join(", ")}`
+			};
+		} catch {
+			return {
+				success: false,
+				error: __optique_core_message.message`Failed to list remotes. Ensure ${(0, __optique_core_message.text)(dir)} is a valid git repository.`
+			};
+		}
+	}, async function* suggestRemote(fs, dir, prefix) {
+		try {
+			const remotes = await isomorphic_git.listRemotes({
+				fs,
+				dir
+			});
+			for (const r of remotes) if ("remote" in r && typeof r.remote === "string" && r.remote.startsWith(prefix)) yield {
+				kind: "literal",
+				text: r.remote
+			};
+		} catch {}
+	});
+}
+/**
+* Creates a value parser that validates commit SHAs.
+*
+* This parser uses isomorphic-git to verify that the provided input
+* is a valid commit SHA (full or shortened) that exists in the repository.
+*
+* @param options Configuration options for the parser.
+* @returns A value parser that accepts valid commit SHAs.
+* @since 0.9.0
+*
+* @example
+* ~~~~ typescript
+* import { gitCommit } from "@optique/git";
+* import { option } from "@optique/core/primitives";
+*
+* const parser = option("-c", "--commit", gitCommit());
+* ~~~~
+*/
+function gitCommit(options) {
+	const metavar = options?.metavar ?? "COMMIT";
+	return createAsyncValueParser(options, metavar, async (fs, dir, input) => {
+		try {
+			const oid = await isomorphic_git.expandOid({
+				fs,
+				dir,
+				oid: input
+			});
+			await isomorphic_git.readObject({
+				fs,
+				dir,
+				oid
+			});
+			return {
+				success: true,
+				value: oid
+			};
+		} catch {
+			return {
+				success: false,
+				error: __optique_core_message.message`Commit ${(0, __optique_core_message.text)(input)} does not exist. Provide a valid commit SHA.`
+			};
+		}
+	}, async function* suggestCommit(fs, dir, prefix) {
+		try {
+			const branches = await isomorphic_git.listBranches({
+				fs,
+				dir
+			});
+			const commits = [];
+			for (const branch of branches.slice(0, 10)) try {
+				const oid = await isomorphic_git.resolveRef({
+					fs,
+					dir,
+					ref: branch
+				});
+				if (oid.startsWith(prefix)) commits.push(oid);
+			} catch {}
+			for (const commit of [...new Set(commits)].slice(0, 10)) yield {
+				kind: "literal",
+				text: commit
+			};
+		} catch {}
+	});
+}
+/**
+* Creates a value parser that validates any git reference
+* (branches, tags, or commits).
+*
+* This parser uses isomorphic-git to verify that the provided input
+* resolves to a valid git reference (branch, tag, or commit SHA).
+*
+* @param options Configuration options for the parser.
+* @returns A value parser that accepts branches, tags, or commit SHAs.
+* @since 0.9.0
+*
+* @example
+* ~~~~ typescript
+* import { gitRef } from "@optique/git";
+* import { option } from "@optique/core/primitives";
+*
+* const parser = option("--ref", gitRef());
+* ~~~~
+*/
+function gitRef(options) {
+	const metavar = options?.metavar ?? "REF";
+	return createAsyncValueParser(options, metavar, async (fs, dir, input) => {
+		try {
+			const oid = await isomorphic_git.resolveRef({
+				fs,
+				dir,
+				ref: input
+			});
+			return {
+				success: true,
+				value: oid
+			};
+		} catch {
+			return {
+				success: false,
+				error: __optique_core_message.message`Reference ${(0, __optique_core_message.text)(input)} does not exist. Provide a valid branch, tag, or commit SHA.`
+			};
+		}
+	}, async function* suggestRef(fs, dir, prefix) {
+		try {
+			const branches = await isomorphic_git.listBranches({
+				fs,
+				dir
+			});
+			for (const branch of branches) if (branch.startsWith(prefix)) yield {
+				kind: "literal",
+				text: branch
+			};
+			const tags = await isomorphic_git.listTags({
+				fs,
+				dir
+			});
+			for (const tag of tags) if (tag.startsWith(prefix)) yield {
+				kind: "literal",
+				text: tag
+			};
+		} catch {}
+	});
+}
+/**
+* Creates a factory for git parsers with shared configuration.
+*
+* This function returns an object with methods for creating individual git
+* parsers that share the same configuration (filesystem and directory).
+*
+* @param options Shared configuration options for all parsers.
+* @returns An object with methods for creating individual git parsers.
+* @since 0.9.0
+*
+* @example
+* ~~~~ typescript
+* import { createGitParsers } from "@optique/git";
+*
+* const git = createGitParsers({ dir: "/path/to/repo" });
+*
+* const branchParser = git.branch();
+* const tagParser = git.tag();
+* ~~~~
+*/
+function createGitParsers(options) {
+	return {
+		branch: (parserOptions) => gitBranch({
+			...options,
+			...parserOptions
+		}),
+		remoteBranch: (remote, parserOptions) => gitRemoteBranch(remote, {
+			...options,
+			...parserOptions
+		}),
+		tag: (parserOptions) => gitTag({
+			...options,
+			...parserOptions
+		}),
+		remote: (parserOptions) => gitRemote({
+			...options,
+			...parserOptions
+		}),
+		commit: (parserOptions) => gitCommit({
+			...options,
+			...parserOptions
+		}),
+		ref: (parserOptions) => gitRef({
+			...options,
+			...parserOptions
+		})
+	};
+}
+
+//#endregion
+exports.createGitParsers = createGitParsers;
+Object.defineProperty(exports, 'expandOid', {
+  enumerable: true,
+  get: function () {
+    return isomorphic_git.expandOid;
+  }
+});
+exports.gitBranch = gitBranch;
+exports.gitCommit = gitCommit;
+exports.gitRef = gitRef;
+exports.gitRemote = gitRemote;
+exports.gitRemoteBranch = gitRemoteBranch;
+exports.gitTag = gitTag;
+Object.defineProperty(exports, 'listBranches', {
+  enumerable: true,
+  get: function () {
+    return isomorphic_git.listBranches;
+  }
+});
+Object.defineProperty(exports, 'listRemotes', {
+  enumerable: true,
+  get: function () {
+    return isomorphic_git.listRemotes;
+  }
+});
+Object.defineProperty(exports, 'listTags', {
+  enumerable: true,
+  get: function () {
+    return isomorphic_git.listTags;
+  }
+});
+Object.defineProperty(exports, 'readObject', {
+  enumerable: true,
+  get: function () {
+    return isomorphic_git.readObject;
+  }
+});
+Object.defineProperty(exports, 'resolveRef', {
+  enumerable: true,
+  get: function () {
+    return isomorphic_git.resolveRef;
+  }
+});