@skuba-lib/api 0.0.0 → 0.1.0-skuba-lib-api-20250925050503

package/lib/git/index.d.mts

@@ -0,0 +1,2 @@
+import { ChangedFile, commit$1 as commit, commitAllChanges$1 as commitAllChanges, currentBranch$1 as currentBranch, fastForwardBranch$1 as fastForwardBranch, findRoot$1 as findRoot, getChangedFiles$1 as getChangedFiles, getHeadCommitId$1 as getHeadCommitId, getHeadCommitMessage$1 as getHeadCommitMessage, getOwnerAndRepo$1 as getOwnerAndRepo, isFileGitIgnored$1 as isFileGitIgnored, push$1 as push, reset$1 as reset } from "../index-DNXQKEza.mjs";
+export { ChangedFile, commit, commitAllChanges, currentBranch, fastForwardBranch, findRoot, getChangedFiles, getHeadCommitId, getHeadCommitMessage, getOwnerAndRepo, isFileGitIgnored, push, reset };

package/lib/git/index.d.ts

@@ -0,0 +1,2 @@
+import { ChangedFile, commit, commitAllChanges, currentBranch, fastForwardBranch, findRoot, getChangedFiles, getHeadCommitId, getHeadCommitMessage, getOwnerAndRepo, isFileGitIgnored, push, reset } from "../index-B91wXiwr.js";
+export { ChangedFile, commit, commitAllChanges, currentBranch, fastForwardBranch, findRoot, getChangedFiles, getHeadCommitId, getHeadCommitMessage, getOwnerAndRepo, isFileGitIgnored, push, reset };

package/lib/git/index.js

@@ -0,0 +1,14 @@
+const require_git = require('../git-DVG_dHiI.js');
+
+exports.commit = require_git.commit;
+exports.commitAllChanges = require_git.commitAllChanges;
+exports.currentBranch = require_git.currentBranch;
+exports.fastForwardBranch = require_git.fastForwardBranch;
+exports.findRoot = require_git.findRoot;
+exports.getChangedFiles = require_git.getChangedFiles;
+exports.getHeadCommitId = require_git.getHeadCommitId;
+exports.getHeadCommitMessage = require_git.getHeadCommitMessage;
+exports.getOwnerAndRepo = require_git.getOwnerAndRepo;
+exports.isFileGitIgnored = require_git.isFileGitIgnored;
+exports.push = require_git.push;
+exports.reset = require_git.reset;

package/lib/git/index.mjs

@@ -0,0 +1,3 @@
+import { commit, commitAllChanges, currentBranch, fastForwardBranch, findRoot, getChangedFiles, getHeadCommitId, getHeadCommitMessage, getOwnerAndRepo, isFileGitIgnored, push, reset } from "../git-DDfcZdbm.mjs";
+
+export { commit, commitAllChanges, currentBranch, fastForwardBranch, findRoot, getChangedFiles, getHeadCommitId, getHeadCommitMessage, getOwnerAndRepo, isFileGitIgnored, push, reset };

package/lib/git-DDfcZdbm.mjs

@@ -0,0 +1,379 @@
+import { __export } from "./chunk-CZCtuq8p.mjs";
+import path from "path";
+import fs from "fs-extra";
+import git, { findRoot } from "isomorphic-git";
+import ignoreFilter from "ignore";
+import http from "isomorphic-git/http/node";
+
+//#region src/git/commit.ts
+/**
+* Writes a commit to the local Git repository.
+*/
+const commit = async ({ author = { name: "skuba" }, committer = { name: "skuba" }, dir, message }) => git.commit({
+	author,
+	committer,
+	dir,
+	fs,
+	message
+});
+
+//#endregion
+//#region src/git/findRoot.ts
+/**
+* Returns the first Git root directory encountered walking up from the provided
+* `dir`.
+*/
+const findRoot$1 = async ({ dir }) => {
+	try {
+		return await git.findRoot({
+			filepath: dir,
+			fs
+		});
+	} catch (err) {
+		if (err instanceof git.Errors.NotFoundError) return null;
+		throw err;
+	}
+};
+
+//#endregion
+//#region src/git/statusMatrix.ts
+const FILEPATH = 0;
+const HEAD = 1;
+const WORKDIR = 2;
+const STAGE = 3;
+const ABSENT = 0;
+const UNMODIFIED = 1;
+const MODIFIED = 2;
+
+//#endregion
+//#region src/git/getChangedFiles.ts
+const mapState = (row) => {
+	if (row[HEAD] === ABSENT) return "added";
+	if (row[WORKDIR] === MODIFIED) return "modified";
+	return "deleted";
+};
+/**
+* Returns all the files which have been added, modified or deleted in the
+* working directory of the local Git repository since the last commit.
+*/
+const getChangedFiles = async ({ dir, ignore = [] }) => {
+	const gitRoot = await findRoot({
+		fs,
+		filepath: dir
+	});
+	const [allFiles, isLfs] = await Promise.all([git.statusMatrix({
+		fs,
+		dir: gitRoot ?? dir
+	}), createIsLfsFilter(gitRoot)]);
+	return allFiles.filter((row) => row[HEAD] !== UNMODIFIED || row[WORKDIR] !== UNMODIFIED || row[STAGE] !== UNMODIFIED).map((row) => ({
+		path: row[FILEPATH],
+		state: mapState(row)
+	})).filter((changedFile) => !ignore.some((i) => i.path === changedFile.path && i.state === changedFile.state) && !isLfs(changedFile.path));
+};
+const createIsLfsFilter = async (gitRoot) => {
+	if (!gitRoot) return () => false;
+	const lfsFile = `${gitRoot}/.gitattributes`;
+	if (!await fs.pathExists(lfsFile)) return () => false;
+	const filter = ignoreFilter().add((await fs.readFile(lfsFile, "utf8")).split("\n").map((l) => l.trim()).filter((l) => !l.startsWith("#") && l.includes("filter=lfs")).map((l) => l.split(/\s+/)[0]).flatMap((l) => l ? [l] : []));
+	return (pathname) => filter.ignores(pathname);
+};
+
+//#endregion
+//#region src/git/commitAllChanges.ts
+/**
+* Stages all changes and writes a commit to the local Git repository.
+*/
+const commitAllChanges = async ({ dir, message, author, committer, ignore }) => {
+	const changedFiles = await getChangedFiles({
+		dir,
+		ignore
+	});
+	if (!changedFiles.length) return;
+	const gitRoot = await findRoot$1({ dir });
+	if (!gitRoot) throw new Error(`Could not find Git root from directory: ${dir}`);
+	await Promise.all(changedFiles.map(async (file) => {
+		const relativePath = path.relative(dir, file.path);
+		if (relativePath.startsWith("..")) return;
+		return file.state === "deleted" ? git.remove({
+			fs,
+			dir: gitRoot,
+			filepath: file.path
+		}) : git.add({
+			fs,
+			dir: gitRoot,
+			filepath: file.path
+		});
+	}));
+	return commit({
+		dir: gitRoot,
+		message,
+		author,
+		committer
+	});
+};
+
+//#endregion
+//#region src/git/currentBranch.ts
+/**
+* Tries to return a Git branch name from CI environment variables.
+*/
+const currentBranchFromEnvironment = (env = process.env) => env.BUILDKITE_BRANCH ?? env.GITHUB_HEAD_REF ?? env.GITHUB_REF_NAME;
+/**
+* Tries to return a Git branch name from CI environment variables, falling back
+* to the local Git repository when the current working `dir` is supplied.
+*/
+const currentBranch = async ({ dir, env = process.env } = {}) => {
+	const fromEnv = currentBranchFromEnvironment(env);
+	if (fromEnv) return fromEnv;
+	if (!dir) return;
+	const gitRoot = await git.findRoot({
+		filepath: dir,
+		fs
+	});
+	const fromRepo = await git.currentBranch({
+		dir: gitRoot,
+		fs
+	});
+	return fromRepo ?? void 0;
+};
+
+//#endregion
+//#region src/git/log.ts
+const EMPTY_GIT_LOG_ERROR = new Error("Git log does not contain any commits");
+/**
+* Gets the object ID of the head commit.
+*
+* This tries to extract the commit ID from common CI environment variables,
+* and falls back to the local Git repository log.
+*/
+const getHeadCommitId = async ({ dir, env = process.env }) => {
+	const oidFromEnv = env.BUILDKITE_COMMIT ?? env.GITHUB_SHA;
+	if (oidFromEnv) return oidFromEnv;
+	const [headResult] = await git.log({
+		depth: 1,
+		dir,
+		fs
+	});
+	if (!headResult) throw EMPTY_GIT_LOG_ERROR;
+	return headResult.oid;
+};
+/**
+* Gets the message of the head commit.
+*
+* This tries to extract the message from common CI environment variables,
+* and falls back to the local Git repository log.
+*/
+const getHeadCommitMessage = async ({ dir, env = process.env }) => {
+	const messageFromEnv = env.BUILDKITE_MESSAGE;
+	if (messageFromEnv) return messageFromEnv;
+	const [headResult] = await git.log({
+		depth: 1,
+		dir,
+		fs
+	});
+	if (!headResult) throw EMPTY_GIT_LOG_ERROR;
+	return headResult.commit.message;
+};
+
+//#endregion
+//#region src/git/remote.ts
+/**
+* Matches the owner and repository names in a GitHub repository URL.
+*
+* For example, given the following input strings:
+*
+* ```console
+* git@github.com:seek-oss/skuba.git
+* https://github.com/seek-oss/skuba.git
+* ```
+*
+* This pattern will produce the following matches:
+*
+* 1. seek-oss
+* 2. skuba
+*/
+const ownerRepoRegex = /github.com(?::|\/)(.+)\/(.+).git$/;
+const ownerAndRepoFromUrl = (url) => {
+	const match = ownerRepoRegex.exec(url);
+	const owner = match?.[1];
+	const repo = match?.[2];
+	return {
+		owner,
+		repo
+	};
+};
+/**
+* Extracts the owner and repository names from CI environment variables,
+* falling back to local Git remotes.
+*
+* Currently, only GitHub repository URLs are supported:
+*
+* ```console
+* git@github.com:seek-oss/skuba.git
+* https://github.com/seek-oss/skuba.git
+* ```
+*/
+const getOwnerAndRepo = async ({ dir, env = process.env }) => {
+	if (env.GITHUB_REPOSITORY) {
+		const [owner, repo] = env.GITHUB_REPOSITORY.split("/");
+		if (owner && repo) return {
+			owner,
+			repo
+		};
+	}
+	if (env.BUILDKITE_REPO) {
+		const { owner, repo } = ownerAndRepoFromUrl(env.BUILDKITE_REPO);
+		if (owner && repo) return {
+			owner,
+			repo
+		};
+	}
+	const gitRoot = await git.findRoot({
+		filepath: dir,
+		fs
+	});
+	const remotes = await git.listRemotes({
+		dir: gitRoot,
+		fs
+	});
+	for (const { url } of remotes) {
+		const { owner, repo } = ownerAndRepoFromUrl(url);
+		if (owner && repo) return {
+			owner,
+			repo
+		};
+	}
+	throw new Error("Could not find a GitHub remote");
+};
+
+//#endregion
+//#region ../../src/utils/env.ts
+/**
+* Whether the code is executing in a CI environment.
+*/
+const isCiEnv = (env = process.env) => Boolean(env.BUILDKITE || env.CI || env.GITHUB_ACTIONS);
+
+//#endregion
+//#region src/github/environment.ts
+/**
+* Returns the name of the build as seen in GitHub status checks.
+*
+* This is driven off of environment variables and falls back to `Build`.
+*/
+const buildNameFromEnvironment = (env = process.env) => {
+	if (env.BUILDKITE_BUILD_NUMBER) return `Build #${env.BUILDKITE_BUILD_NUMBER}`;
+	if (env.GITHUB_RUN_NUMBER) return `${env.GITHUB_WORKFLOW ?? "Build"} #${env.GITHUB_RUN_NUMBER}`;
+	return "Build";
+};
+/**
+* Whether GitHub API interactions should be enabled.
+*
+* This checks environment variables to see if the code is executing in a CI
+* environment and has access to a GitHub API token.
+*/
+const enabledFromEnvironment = (env = process.env) => isCiEnv(env) && Boolean(apiTokenFromEnvironment(env));
+/**
+* Tries to return a GitHub API token from the environment.
+*/
+const apiTokenFromEnvironment = (env = process.env) => env.GITHUB_API_TOKEN ?? env.GITHUB_TOKEN;
+
+//#endregion
+//#region src/git/push.ts
+/**
+* Pushes the specified `ref` from the local Git repository to a remote.
+*/
+const push = async ({ auth, dir, ref, remote, remoteRef, force }) => {
+	const { owner, repo } = await getOwnerAndRepo({ dir });
+	const url = `https://github.com/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`;
+	return git.push({
+		onAuth: () => ({
+			username: "x-access-token",
+			password: auth.token ?? apiTokenFromEnvironment()
+		}),
+		dir,
+		fs,
+		http,
+		ref,
+		remote,
+		remoteRef,
+		url,
+		force
+	});
+};
+
+//#endregion
+//#region src/git/pull.ts
+/**
+* Fast forwards the specified `ref` on the local Git repository to match the remote branch.
+*/
+const fastForwardBranch = async ({ auth, dir, ref, remote, remoteRef }) => {
+	const { owner, repo } = await getOwnerAndRepo({ dir });
+	const url = `https://github.com/${encodeURIComponent(owner)}/${encodeURIComponent(repo)}`;
+	return git.fastForward({
+		onAuth: () => ({
+			username: "x-access-token",
+			password: auth.token ?? apiTokenFromEnvironment()
+		}),
+		dir,
+		fs,
+		http,
+		ref,
+		remote,
+		remoteRef,
+		url,
+		singleBranch: true
+	});
+};
+
+//#endregion
+//#region src/git/reset.ts
+/**
+* Resets the specified branch in the local Git repository to a particular
+* commit.
+*/
+const reset = async ({ dir, branch, commitId, hard }) => {
+	await fs.promises.writeFile(path.join(dir, ".git/refs/heads", branch), `${commitId}\n`);
+	if (hard) {
+		const allFiles = await git.statusMatrix({
+			dir,
+			fs
+		});
+		const modifiedFiles = allFiles.filter((row) => row[WORKDIR] > UNMODIFIED && row[STAGE] > UNMODIFIED).map((row) => row[FILEPATH]);
+		await Promise.all(modifiedFiles.map((filePath) => fs.promises.rm(filePath)));
+		await git.checkout({
+			dir,
+			fs,
+			ref: branch,
+			force: true
+		});
+	}
+};
+
+//#endregion
+//#region src/git/isFileGitIgnored.ts
+const isFileGitIgnored = ({ absolutePath, gitRoot }) => git.isIgnored({
+	dir: gitRoot,
+	filepath: path.relative(gitRoot, absolutePath),
+	fs
+});
+
+//#endregion
+//#region src/git/index.ts
+var git_exports = {};
+__export(git_exports, {
+	commit: () => commit,
+	commitAllChanges: () => commitAllChanges,
+	currentBranch: () => currentBranch,
+	fastForwardBranch: () => fastForwardBranch,
+	findRoot: () => findRoot$1,
+	getChangedFiles: () => getChangedFiles,
+	getHeadCommitId: () => getHeadCommitId,
+	getHeadCommitMessage: () => getHeadCommitMessage,
+	getOwnerAndRepo: () => getOwnerAndRepo,
+	isFileGitIgnored: () => isFileGitIgnored,
+	push: () => push,
+	reset: () => reset
+});
+
+//#endregion
+export { apiTokenFromEnvironment, buildNameFromEnvironment, commit, commitAllChanges, currentBranch, enabledFromEnvironment, fastForwardBranch, findRoot$1 as findRoot, getChangedFiles, getHeadCommitId, getHeadCommitMessage, getOwnerAndRepo, git_exports, isFileGitIgnored, push, reset };