@fuzdev/fuz_gitops 0.57.0

package/src/lib/fetch_repo_data.ts

@@ -0,0 +1,64 @@
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import {wait} from '@fuzdev/fuz_util/async.js';
+import type {FetchValueCache} from '@fuzdev/fuz_util/fetch.js';
+
+import {fetch_github_check_runs, fetch_github_pull_requests} from './github.js';
+import type {RepoJson} from './repo.svelte.js';
+import type {LocalRepo} from './local_repo.js';
+
+/* eslint-disable no-await-in-loop */
+
+/**
+ * Fetches GitHub metadata (CI status, PRs) for all repos.
+ *
+ * Fetches sequentially with delay between requests to respect GitHub API rate limits.
+ * Uses `await_in_loop` intentionally to avoid parallel requests overwhelming the API.
+ *
+ * Error handling: Logs fetch failures but continues processing remaining repos.
+ * Repos with failed fetches will have `null` for check_runs or pull_requests.
+ *
+ * @param delay milliseconds between API requests (default: 33ms)
+ * @param cache optional cache from belt's fetch.js for response memoization
+ * @returns array of Repo objects with GitHub metadata attached
+ */
+export const fetch_repo_data = async (
+	resolved_repos: Array<LocalRepo>,
+	token?: string,
+	cache?: FetchValueCache,
+	log?: Logger,
+	delay = 33,
+	github_api_version?: string,
+): Promise<Array<RepoJson>> => {
+	const repos: Array<RepoJson> = [];
+	for (const {library, library_json, repo_config} of resolved_repos) {
+		const repo_url = library.repo_url;
+
+		// CI status
+		await wait(delay);
+		const check_runs = await fetch_github_check_runs(library, {
+			cache,
+			log,
+			token,
+			api_version: github_api_version,
+			ref: repo_config.branch,
+		});
+		if (!check_runs) log?.error('failed to fetch CI status: ' + repo_url);
+
+		// pull requests
+		await wait(delay);
+		const pull_requests = await fetch_github_pull_requests(library, {
+			cache,
+			log,
+			token,
+			api_version: github_api_version,
+		});
+		if (!pull_requests) log?.error('failed to fetch issues: ' + repo_url);
+
+		repos.push({
+			library_json,
+			check_runs,
+			pull_requests,
+		});
+	}
+	return repos;
+};

package/src/lib/fs_fetch_value_cache.ts

@@ -0,0 +1,75 @@
+import {mkdir, readFile, rm, writeFile} from 'node:fs/promises';
+import {dirname, join} from 'node:path';
+import {paths} from '@ryanatkn/gro/paths.js';
+import {format_file} from '@ryanatkn/gro/format_file.js';
+import {deserialize_cache, serialize_cache, type FetchValueCache} from '@fuzdev/fuz_util/fetch.js';
+import {existsSync} from 'node:fs';
+
+// TODO upstream to Gro probably, and rename/redesign?
+
+export interface FetchCache {
+	name: string;
+	data: FetchValueCache; // TODO probably expose an API for this instead of passing the map directly
+	/**
+	 * @returns true if anything changed, false if no-op
+	 */
+	save: () => Promise<boolean>;
+}
+
+/**
+ * Creates file-system backed cache for belt's fetch.js API responses.
+ *
+ * Cache invalidation strategy: If cache file can't be read or parsed, entire
+ * cache is cleared (delete file) and starts fresh. This handles format changes.
+ *
+ * Uses `structuredClone` to track changes - only writes to disk if data modified.
+ * Formatted with Prettier before writing for version control friendliness.
+ *
+ * @param name cache filename (without .json extension)
+ * @param dir cache directory (defaults to `.gro/build/fetch/`)
+ * @returns cache object with Map-based data and save() method
+ */
+export const create_fs_fetch_value_cache = async (
+	name: string,
+	dir = join(paths.build, 'fetch'),
+): Promise<FetchCache> => {
+	const data_path = join(dir, name + '.json');
+	let data: FetchValueCache;
+	if (existsSync(data_path)) {
+		try {
+			data = deserialize_cache(await readFile(data_path, 'utf8')); // TODO pass schema to parse so failures invalidate the cache
+		} catch (_err) {
+			// something went wrong, maybe the data format changed, so clear the cache
+			data = new Map();
+			await rm(data_path);
+		}
+	} else {
+		data = new Map();
+	}
+	const initial = structuredClone(data);
+	return {
+		name,
+		data,
+		save: async () => {
+			if (deep_equal_maps(initial, data)) {
+				return false; // no changes to save
+			}
+			await mkdir(dirname(data_path), {recursive: true});
+			await writeFile(data_path, await format_file(serialize_cache(data), {filepath: data_path}));
+			return true;
+		},
+	};
+};
+
+// TODO this is quick and dirty, but fine because it's only expected to be called during development
+const deep_equal_maps = (a: Map<unknown, unknown>, b: Map<unknown, unknown>): boolean => {
+	if (a.size !== b.size) {
+		return false;
+	}
+	for (const [key, value] of a) {
+		if (!b.has(key) || JSON.stringify(b.get(key)) !== JSON.stringify(value)) {
+			return false;
+		}
+	}
+	return true;
+};

package/src/lib/git_operations.ts

@@ -0,0 +1,208 @@
+import {spawn, spawn_out} from '@fuzdev/fuz_util/process.js';
+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.js';
+
+/**
+ * Adds files to git staging area and throws if anything goes wrong.
+ */
+export const git_add = async (
+	files: string | Array<string>,
+	options?: SpawnOptions,
+): Promise<void> => {
+	const file_list = Array.isArray(files) ? files : [files];
+	const result = await spawn('git', ['add', ...file_list], options);
+	if (!result.ok) {
+		throw Error(`git_add failed with code ${result.code}`);
+	}
+};
+
+/**
+ * Commits staged changes with a message and throws if anything goes wrong.
+ */
+export const git_commit = async (message: string, options?: SpawnOptions): Promise<void> => {
+	const result = await spawn('git', ['commit', '-m', message], options);
+	if (!result.ok) {
+		throw Error(`git_commit failed with code ${result.code}`);
+	}
+};
+
+/**
+ * Adds files and commits in one operation and throws if anything goes wrong.
+ */
+export const git_add_and_commit = async (
+	files: string | Array<string>,
+	message: 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 = await spawn('git', args, options);
+	if (!result.ok) {
+		throw Error(`git_tag failed for tag '${tag_name}' with code ${result.code}`);
+	}
+};
+
+/**
+ * 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 = await spawn('git', ['push', origin, tag_name], options);
+	if (!result.ok) {
+		throw Error(`git_push_tag failed for tag '${tag_name}' with code ${result.code}`);
+	}
+};
+
+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;
+};
+
+/**
+ * Returns list of changed files compared to HEAD.
+ */
+export const git_get_changed_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(
+		'git',
+		['diff', '--name-only', from_commit, to_commit, '--', file_path],
+		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 = await spawn('git', args, options);
+	if (!result.ok) {
+		throw Error(`git_stash failed with code ${result.code}`);
+	}
+};
+
+/**
+ * Applies stashed changes and throws if anything goes wrong.
+ */
+export const git_stash_pop = async (options?: SpawnOptions): Promise<void> => {
+	const result = await spawn('git', ['stash', 'pop'], options);
+	if (!result.ok) {
+		throw Error(`git_stash_pop failed with code ${result.code}`);
+	}
+};
+
+/**
+ * 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.
+ */
+export const git_current_commit_hash_required = async (
+	branch?: string,
+	options?: SpawnOptions,
+): Promise<string> => {
+	const hash = await gro_git_current_commit_hash(branch, options);
+	if (!hash) {
+		throw new Error(`Failed to get commit hash for branch: ${branch || 'current'}`);
+	}
+	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

@@ -0,0 +1,128 @@
+import type {Logger} from '@fuzdev/fuz_util/log.js';
+import {z} from 'zod';
+import {fetch_value, type FetchValueCache} from '@fuzdev/fuz_util/fetch.js';
+
+/**
+ * Minimal interface for GitHub API calls - works with both Pkg and Repo.
+ */
+export interface GithubRepoInfo {
+	owner_name: string | null;
+	repo_name: string;
+}
+
+/**
+ * @see https://docs.github.com/en/rest/pulls/pulls?apiVersion=2022-11-28#list-pull-requests
+ */
+export const GithubPullRequest = z.object({
+	number: z.number(),
+	title: z.string(),
+	user: z.object({
+		login: z.string(),
+	}),
+	draft: z.boolean(),
+});
+export type GithubPullRequest = z.infer<typeof GithubPullRequest>;
+export const GithubPullRequests = z.array(GithubPullRequest);
+export type GithubPullRequests = z.infer<typeof GithubPullRequests>;
+
+/**
+ * @see https://docs.github.com/en/rest/pulls/pulls?apiVersion=2022-11-28#list-pull-requests
+ */
+export const fetch_github_pull_requests = async (
+	repo_info: GithubRepoInfo,
+	options: {
+		cache?: FetchValueCache;
+		log?: Logger;
+		token?: string;
+		api_version?: string;
+	} = {},
+): Promise<GithubPullRequests | null> => {
+	const {cache, log, token, api_version} = 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 url = `https://api.github.com/repos/${repo_info.owner_name}/${repo_info.repo_name}/pulls`;
+	const fetched = await fetch_value(url, {
+		request: {headers},
+		parse: GithubPullRequests.parse,
+		token,
+		cache,
+		log,
+	});
+	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',
+			);
+		}
+		return null;
+	}
+	return fetched.value;
+};
+
+/**
+ * @see https://docs.github.com/en/rest/checks/runs?apiVersion=2022-11-28#list-check-runs-for-a-git-reference
+ */
+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(),
+});
+export type GithubCheckRunsItem = z.infer<typeof GithubCheckRunsItem>;
+export const GithubCheckRuns = z.object({
+	total_count: z.number(),
+	check_runs: z.array(GithubCheckRunsItem),
+});
+export type GithubCheckRuns = z.infer<typeof GithubCheckRuns>;
+
+/**
+ * @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 (
+	repo_info: GithubRepoInfo,
+	options: {
+		cache?: FetchValueCache;
+		log?: Logger;
+		token?: string;
+		api_version?: string;
+		ref?: string;
+	} = {},
+): Promise<GithubCheckRunsItem | null> => {
+	const {cache, log, token, api_version, ref = 'main'} = 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 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},
+		parse: (v) => reduce_check_runs(GithubCheckRuns.parse(v).check_runs),
+		token,
+		cache,
+		log,
+	});
+	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 fetched.value;
+};
+
+const reduce_check_runs = (check_runs: Array<GithubCheckRunsItem>): GithubCheckRunsItem | null => {
+	if (!check_runs.length) return null;
+	// TODO fix these types and remove the eslint disable, `GithubCheckRunsItem` should maybe have nullable properties?
+	let status!: GithubCheckRunsItem['status'];
+	let conclusion!: GithubCheckRunsItem['conclusion'];
+	for (const check_run of check_runs) {
+		// eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+		if (!status || status === 'completed') {
+			status = check_run.status;
+		}
+		if (!conclusion || conclusion === 'success') {
+			conclusion = check_run.conclusion;
+		}
+	}
+	return {status, conclusion};
+};

package/src/lib/github_helpers.ts

@@ -0,0 +1,31 @@
+import {ensure_end} from '@fuzdev/fuz_util/string.js';
+
+import type {GithubPullRequest} from './github.js';
+import type {Repo} from './repo.svelte.js';
+
+export type FilterPullRequest = (pull_request: GithubPullRequest, repo: Repo) => boolean;
+
+export interface PullRequestMeta {
+	repo: Repo;
+	pull_request: GithubPullRequest;
+}
+
+export const to_pull_requests = (
+	repos: Array<Repo>,
+	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);
+
+export const to_pull_url = (repo_url: string, pull: GithubPullRequest): string =>
+	ensure_end(repo_url, '/') + 'pull/' + pull.number;