@fuzdev/fuz_gitops 0.78.0 → 0.79.0

package/src/lib/git_operations.ts

@@ -1,227 +1,55 @@
-import {spawn_out, spawn_result_to_message} from '@fuzdev/fuz_util/process.ts';
-import type {SpawnOptions} from 'node:child_process';
-import {
-	git_check_clean_workspace as gro_git_check_clean_workspace,
-	git_checkout as gro_git_checkout,
-	git_pull as gro_git_pull,
-	git_current_branch_name as gro_git_current_branch_name,
-	git_current_commit_hash as gro_git_current_commit_hash,
-	type GitBranch,
-	type GitOrigin,
-} from '@fuzdev/fuz_util/git.ts';
+import { spawn_out, spawn_result_to_message } from '@fuzdev/fuz_util/process.ts';
+import type { SpawnOptions } from 'node:child_process';
+import { git_current_commit_hash as gro_git_current_commit_hash } from '@fuzdev/fuz_util/git.ts';
 
 /**
  * Adds files to git staging area and throws if anything goes wrong.
  */
 export const git_add = async (
 	files: string | Array<string>,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<void> => {
 	const file_list = Array.isArray(files) ? files : [files];
-	const {result, stderr} = await spawn_out('git', ['add', ...file_list], options);
+	const { result, stderr } = await spawn_out('git', ['add', ...file_list], options);
 	if (!result.ok) {
 		throw Error(
-			`git_add failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
+			`git_add failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
 
 /**
- * Commits staged changes with a message and throws if anything goes wrong.
+ * Commits `files` alone with a message, leaving anything else staged out of
+ * the commit, and throws if anything goes wrong. `files` must be non-empty:
+ * an empty list would commit the whole index.
  */
-export const git_commit = async (message: string, options?: SpawnOptions): Promise<void> => {
-	const {result, stderr} = await spawn_out('git', ['commit', '-m', message], options);
-	if (!result.ok) {
-		throw Error(
-			`git_commit failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
-		);
-	}
-};
-
-/**
- * Adds files and commits in one operation and throws if anything goes wrong.
- */
-export const git_add_and_commit = async (
-	files: string | Array<string>,
+export const git_commit = async (
 	message: string,
-	options?: SpawnOptions,
+	files: Array<string>,
+	options?: SpawnOptions
 ): Promise<void> => {
-	await git_add(files, options);
-	await git_commit(message, options);
-};
-
-/**
- * Creates a git tag and throws if anything goes wrong.
- */
-export const git_tag = async (
-	tag_name: string,
-	message?: string,
-	options?: SpawnOptions,
-): Promise<void> => {
-	const args = message ? ['tag', '-a', tag_name, '-m', message] : ['tag', tag_name];
-
-	const {result, stderr} = await spawn_out('git', args, options);
-	if (!result.ok) {
-		throw Error(
-			`git_tag failed for tag '${tag_name}' with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
-		);
+	if (files.length === 0) {
+		throw Error('git_commit needs at least one file: an empty list would commit the whole index');
 	}
-};
-
-/**
- * Pushes a tag to origin and throws if anything goes wrong.
- */
-export const git_push_tag = async (
-	tag_name: string,
-	origin: GitOrigin = 'origin' as GitOrigin,
-	options?: SpawnOptions,
-): Promise<void> => {
-	const {result, stderr} = await spawn_out('git', ['push', origin, tag_name], options);
-	if (!result.ok) {
-		throw Error(
-			`git_push_tag failed for tag '${tag_name}' with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
-		);
-	}
-};
-
-/**
- * Returns `true` if the working tree has any changes — staged, unstaged, or
- * untracked (`git status --porcelain`). Broader than `git_list_uncommitted_files`,
- * which reports only tracked working-tree changes relative to HEAD.
- */
-export const git_has_changes = async (options?: SpawnOptions): Promise<boolean> => {
-	const {stdout} = await spawn_out('git', ['status', '--porcelain'], options);
-	return stdout ? stdout.trim().length > 0 : false;
-};
-
-/**
- * Lists uncommitted files in the working tree (`git diff --name-only HEAD`).
- */
-export const git_list_uncommitted_files = async (
-	options?: SpawnOptions,
-): Promise<Array<string>> => {
-	const {stdout} = await spawn_out('git', ['diff', '--name-only', 'HEAD'], options);
-	if (!stdout) return [];
-
-	return stdout
-		.split('\n')
-		.map((f) => f.trim())
-		.filter(Boolean);
-};
-
-export const git_has_file_changed = async (
-	from_commit: string,
-	to_commit: string,
-	file_path: string,
-	options?: SpawnOptions,
-): Promise<boolean> => {
-	const {stdout} = await spawn_out(
+	const { result, stderr } = await spawn_out(
 		'git',
-		['diff', '--name-only', from_commit, to_commit, '--', file_path],
-		options,
+		['commit', '-m', message, '--', ...files],
+		options
 	);
-	return stdout ? stdout.trim().length > 0 : false;
-};
-
-/**
- * Stashes current changes and throws if anything goes wrong.
- */
-export const git_stash = async (message?: string, options?: SpawnOptions): Promise<void> => {
-	const args = message ? ['stash', 'push', '-m', message] : ['stash', 'push'];
-
-	const {result, stderr} = await spawn_out('git', args, options);
-	if (!result.ok) {
-		throw Error(
-			`git_stash failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
-		);
-	}
-};
-
-/**
- * Applies stashed changes and throws if anything goes wrong.
- */
-export const git_stash_pop = async (options?: SpawnOptions): Promise<void> => {
-	const {result, stderr} = await spawn_out('git', ['stash', 'pop'], options);
 	if (!result.ok) {
 		throw Error(
-			`git_stash_pop failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`,
+			`git_commit failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
 
 /**
- * Switches to a branch with safety checks and throws if workspace is not clean.
- */
-export const git_switch_branch = async (
-	branch: GitBranch,
-	pull: boolean = true,
-	options?: SpawnOptions,
-): Promise<void> => {
-	// Check if workspace is clean first
-	const error = await gro_git_check_clean_workspace(options);
-	if (error) {
-		throw Error(`Cannot switch branch: ${error}`);
-	}
-
-	// Checkout the branch
-	await gro_git_checkout(branch, options);
-
-	// Pull latest changes if requested
-	if (pull) {
-		await gro_git_pull(undefined, undefined, options);
-	}
-
-	// Verify workspace is still clean
-	const error_after = await gro_git_check_clean_workspace(options);
-	if (error_after) {
-		throw Error(`Workspace unclean after switching to ${branch}: ${error_after}`);
-	}
-};
-
-/**
- * Wrapper for gro's `git_current_branch_name` that throws if null.
- */
-export const git_current_branch_name_required = async (options?: SpawnOptions): Promise<string> => {
-	const branch = await gro_git_current_branch_name(options);
-	if (!branch) {
-		throw new Error('Failed to get current branch name');
-	}
-	return branch;
-};
-
-/**
- * Wrapper for gro's `git_current_commit_hash` that throws if null.
+ * Wrapper for gro's `git_current_commit_hash` that reads `HEAD` and throws if null.
  */
-export const git_current_commit_hash_required = async (
-	branch?: string,
-	options?: SpawnOptions,
-): Promise<string> => {
-	const hash = await gro_git_current_commit_hash(branch, options);
+export const git_current_commit_hash_required = async (options?: SpawnOptions): Promise<string> => {
+	const hash = await gro_git_current_commit_hash(undefined, options);
 	if (!hash) {
-		throw new Error(`Failed to get commit hash for branch: ${branch || 'current'}`);
+		throw new Error('Failed to get the current commit hash');
 	}
 	return hash;
 };
-
-/**
- * Wrapper for gro's `git_check_clean_workspace` that returns a boolean.
- */
-export const git_check_clean_workspace_as_boolean = async (
-	options?: SpawnOptions,
-): Promise<boolean> => {
-	const error = await gro_git_check_clean_workspace(options);
-	return error === null;
-};
-
-export const git_has_remote = async (
-	remote: string = 'origin',
-	options?: SpawnOptions,
-): Promise<boolean> => {
-	const {stdout} = await spawn_out('git', ['remote'], options);
-	if (!stdout) return false;
-	const remotes = stdout
-		.split('\n')
-		.map((r) => r.trim())
-		.filter(Boolean);
-	return remotes.includes(remote);
-};

package/src/lib/github.ts

@@ -1,9 +1,10 @@
-import type {Logger} from '@fuzdev/fuz_util/log.ts';
-import {z} from 'zod';
-import {fetch_value, type FetchValueCache} from '@fuzdev/fuz_util/fetch.ts';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { z } from 'zod';
+import { fetch_value, type FetchValueCache } from '@fuzdev/fuz_util/fetch.ts';
+import type { Result } from '@fuzdev/fuz_util/result.ts';
 
 /**
- * Minimal interface for GitHub API calls - works with both `Pkg` and `Repo`.
+ * Minimal interface for GitHub API calls, satisfied structurally by fuz_ui's `Library`.
  */
 export interface GithubRepoInfo {
 	owner_name: string | null;
@@ -17,9 +18,9 @@ export const GithubPullRequest = z.object({
 	number: z.number(),
 	title: z.string(),
 	user: z.object({
-		login: z.string(),
+		login: z.string()
 	}),
-	draft: z.boolean(),
+	draft: z.boolean()
 });
 export type GithubPullRequest = z.infer<typeof GithubPullRequest>;
 export const GithubPullRequests = z.array(GithubPullRequest);
@@ -35,24 +36,26 @@ export const fetch_github_pull_requests = async (
 		log?: Logger;
 		token?: string;
 		api_version?: string;
-	} = {},
+		fetch?: typeof globalThis.fetch;
+	} = {}
 ): Promise<GithubPullRequests | null> => {
-	const {cache, log, token, api_version} = options;
+	const { cache, log, token, api_version, fetch } = options;
 	if (!repo_info.owner_name) throw Error('owner_name is required');
-	const headers = api_version ? new Headers({'x-github-api-version': api_version}) : undefined;
+	const headers = api_version ? new Headers({ 'x-github-api-version': api_version }) : undefined;
 	const url = `https://api.github.com/repos/${repo_info.owner_name}/${repo_info.repo_name}/pulls`;
 	const fetched = await fetch_value(url, {
-		request: {headers},
+		request: { headers },
 		parse: GithubPullRequests.parse,
 		token,
 		cache,
 		log,
+		fetch
 	});
 	if (!fetched.ok) {
 		// TODO @many this is messy but I think it's the main case we need to worry about?
 		if (fetched.status === 401) {
 			throw Error(
-				'401 response fetching github pull requests - check your SECRET_GITHUB_API_TOKEN',
+				'401 response fetching github pull requests - check your SECRET_GITHUB_API_TOKEN'
 			);
 		}
 		return null;
@@ -67,16 +70,23 @@ export const GithubCheckRunsItem = z.object({
 	status: z.enum(['queued', 'in_progress', 'completed']),
 	conclusion: z
 		.enum(['success', 'failure', 'neutral', 'cancelled', 'skipped', 'timed_out', 'action_required'])
-		.nullable(),
+		.nullable()
 });
 export type GithubCheckRunsItem = z.infer<typeof GithubCheckRunsItem>;
 export const GithubCheckRuns = z.object({
 	total_count: z.number(),
-	check_runs: z.array(GithubCheckRunsItem),
+	check_runs: z.array(GithubCheckRunsItem)
 });
 export type GithubCheckRuns = z.infer<typeof GithubCheckRuns>;
 
 /**
+ * Fetches the check runs on `ref` and reduces them to one overall status and
+ * conclusion.
+ *
+ * @param repo_info - the repo's GitHub owner and name
+ * @param options - the cache, logger, token, API version, ref (`main` by default), and `fetch`
+ * @returns the reduced check runs, `null` for a ref with none (a repo without CI, or a commit CI skipped), or a failure when the request or its parse failed
+ * @throws {Error} on a 401 response (check `SECRET_GITHUB_API_TOKEN`) or a repo without an owner
  * @see https://docs.github.com/en/rest/checks/runs?apiVersion=2022-11-28#list-check-runs-for-a-git-reference
  */
 export const fetch_github_check_runs = async (
@@ -87,27 +97,29 @@ export const fetch_github_check_runs = async (
 		token?: string;
 		api_version?: string;
 		ref?: string;
-	} = {},
-): Promise<GithubCheckRunsItem | null> => {
-	const {cache, log, token, api_version, ref = 'main'} = options;
+		fetch?: typeof globalThis.fetch;
+	} = {}
+): Promise<Result<{ value: GithubCheckRunsItem | null }, { status: number; message: string }>> => {
+	const { cache, log, token, api_version, ref = 'main', fetch } = options;
 	if (!repo_info.owner_name) throw Error('owner_name is required');
-	const headers = api_version ? new Headers({'x-github-api-version': api_version}) : undefined;
+	const headers = api_version ? new Headers({ 'x-github-api-version': api_version }) : undefined;
 	const url = `https://api.github.com/repos/${repo_info.owner_name}/${repo_info.repo_name}/commits/${ref}/check-runs`;
 	const fetched = await fetch_value(url, {
-		request: {headers},
+		request: { headers },
 		parse: (v) => reduce_check_runs(GithubCheckRuns.parse(v).check_runs),
 		token,
 		cache,
 		log,
+		fetch
 	});
 	if (!fetched.ok) {
 		// TODO @many this is messy but I think it's the main case we need to worry about?
 		if (fetched.status === 401) {
 			throw Error('401 response fetching github CI status - check your SECRET_GITHUB_API_TOKEN');
 		}
-		return null;
+		return { ok: false, status: fetched.status, message: fetched.message };
 	}
-	return fetched.value;
+	return { ok: true, value: fetched.value };
 };
 
 const reduce_check_runs = (check_runs: Array<GithubCheckRunsItem>): GithubCheckRunsItem | null => {
@@ -123,5 +135,5 @@ const reduce_check_runs = (check_runs: Array<GithubCheckRunsItem>): GithubCheckR
 			conclusion = check_run.conclusion;
 		}
 	}
-	return {status, conclusion};
+	return { status, conclusion };
 };

package/src/lib/github_helpers.ts

@@ -1,7 +1,7 @@
-import {ensure_end} from '@fuzdev/fuz_util/string.ts';
+import { ensure_end } from '@fuzdev/fuz_util/string.ts';
 
-import type {GithubPullRequest} from './github.ts';
-import type {Repo} from './repo.svelte.ts';
+import type { GithubPullRequest } from './github.ts';
+import type { Repo } from './repo.svelte.ts';
 
 export type FilterPullRequest = (pull_request: GithubPullRequest, repo: Repo) => boolean;
 
@@ -12,20 +12,13 @@ export interface PullRequestMeta {
 
 export const to_pull_requests = (
 	repos: Array<Repo>,
-	filter_pull_request?: FilterPullRequest,
+	filter_pull_request?: FilterPullRequest
 ): Array<PullRequestMeta> =>
-	repos
-		.flatMap((repo) => {
-			if (!repo.pull_requests) return null;
-			// TODO hacky, figure out the data structure
-			return repo.pull_requests.map((pull_request) =>
-				repo.package_json.homepage &&
-				(!filter_pull_request || filter_pull_request(pull_request, repo))
-					? {repo, pull_request}
-					: null,
-			);
-		})
-		.filter((v) => v !== null);
+	repos.flatMap((repo) =>
+		(repo.pull_requests ?? [])
+			.filter((pull_request) => !filter_pull_request || filter_pull_request(pull_request, repo))
+			.map((pull_request) => ({ repo, pull_request }))
+	);
 
 export const to_pull_url = (repo_url: string, pull: GithubPullRequest): string =>
 	ensure_end(repo_url, '/') + 'pull/' + pull.number;