@fuzdev/fuz_gitops 0.77.0 → 0.78.1

package/src/lib/git_operations.ts

@@ -1,5 +1,5 @@
-import {spawn_out, spawn_result_to_message} from '@fuzdev/fuz_util/process.js';
-import type {SpawnOptions} from 'node:child_process';
+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,
@@ -7,21 +7,21 @@ import {
 	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';
+	type GitOrigin
+} 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() : ''}`
 		);
 	}
 };
@@ -30,10 +30,10 @@ export const git_add = async (
  * 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, stderr} = await spawn_out('git', ['commit', '-m', message], options);
+	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() : ''}`,
+			`git_commit failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -44,7 +44,7 @@ export const git_commit = async (message: string, options?: SpawnOptions): Promi
 export const git_add_and_commit = async (
 	files: string | Array<string>,
 	message: string,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<void> => {
 	await git_add(files, options);
 	await git_commit(message, options);
@@ -56,14 +56,14 @@ export const git_add_and_commit = async (
 export const git_tag = async (
 	tag_name: string,
 	message?: string,
-	options?: SpawnOptions,
+	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);
+	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() : ''}`,
+			`git_tag failed for tag '${tag_name}' with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -74,12 +74,12 @@ export const git_tag = async (
 export const git_push_tag = async (
 	tag_name: string,
 	origin: GitOrigin = 'origin' as GitOrigin,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<void> => {
-	const {result, stderr} = await spawn_out('git', ['push', origin, tag_name], options);
+	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() : ''}`,
+			`git_push_tag failed for tag '${tag_name}' with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -90,7 +90,7 @@ export const git_push_tag = async (
  * 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);
+	const { stdout } = await spawn_out('git', ['status', '--porcelain'], options);
 	return stdout ? stdout.trim().length > 0 : false;
 };
 
@@ -98,9 +98,9 @@ export const git_has_changes = async (options?: SpawnOptions): Promise<boolean>
  * Lists uncommitted files in the working tree (`git diff --name-only HEAD`).
  */
 export const git_list_uncommitted_files = async (
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<Array<string>> => {
-	const {stdout} = await spawn_out('git', ['diff', '--name-only', 'HEAD'], options);
+	const { stdout } = await spawn_out('git', ['diff', '--name-only', 'HEAD'], options);
 	if (!stdout) return [];
 
 	return stdout
@@ -113,12 +113,12 @@ export const git_has_file_changed = async (
 	from_commit: string,
 	to_commit: string,
 	file_path: string,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<boolean> => {
-	const {stdout} = await spawn_out(
+	const { stdout } = await spawn_out(
 		'git',
 		['diff', '--name-only', from_commit, to_commit, '--', file_path],
-		options,
+		options
 	);
 	return stdout ? stdout.trim().length > 0 : false;
 };
@@ -129,10 +129,10 @@ export const git_has_file_changed = async (
 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);
+	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() : ''}`,
+			`git_stash failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -141,10 +141,10 @@ export const git_stash = async (message?: string, options?: SpawnOptions): Promi
  * 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);
+	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_stash_pop failed with ${spawn_result_to_message(result)}${stderr ? ': ' + stderr.trim() : ''}`
 		);
 	}
 };
@@ -155,7 +155,7 @@ export const git_stash_pop = async (options?: SpawnOptions): Promise<void> => {
 export const git_switch_branch = async (
 	branch: GitBranch,
 	pull: boolean = true,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<void> => {
 	// Check if workspace is clean first
 	const error = await gro_git_check_clean_workspace(options);
@@ -194,7 +194,7 @@ export const git_current_branch_name_required = async (options?: SpawnOptions):
  */
 export const git_current_commit_hash_required = async (
 	branch?: string,
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<string> => {
 	const hash = await gro_git_current_commit_hash(branch, options);
 	if (!hash) {
@@ -207,7 +207,7 @@ export const git_current_commit_hash_required = async (
  * Wrapper for gro's `git_check_clean_workspace` that returns a boolean.
  */
 export const git_check_clean_workspace_as_boolean = async (
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<boolean> => {
 	const error = await gro_git_check_clean_workspace(options);
 	return error === null;
@@ -215,9 +215,9 @@ export const git_check_clean_workspace_as_boolean = async (
 
 export const git_has_remote = async (
 	remote: string = 'origin',
-	options?: SpawnOptions,
+	options?: SpawnOptions
 ): Promise<boolean> => {
-	const {stdout} = await spawn_out('git', ['remote'], options);
+	const { stdout } = await spawn_out('git', ['remote'], options);
 	if (!stdout) return false;
 	const remotes = stdout
 		.split('\n')

package/src/lib/github.ts

@@ -1,6 +1,6 @@
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {z} from 'zod';
-import {fetch_value, type FetchValueCache} from '@fuzdev/fuz_util/fetch.js';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { z } from 'zod';
+import { fetch_value, type FetchValueCache } from '@fuzdev/fuz_util/fetch.ts';
 
 /**
  * Minimal interface for GitHub API calls - works with both `Pkg` and `Repo`.
@@ -17,9 +17,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 +35,24 @@ export const fetch_github_pull_requests = async (
 		log?: Logger;
 		token?: string;
 		api_version?: string;
-	} = {},
+	} = {}
 ): Promise<GithubPullRequests | null> => {
-	const {cache, log, token, api_version} = options;
+	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 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,
+		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',
+				'401 response fetching github pull requests - check your SECRET_GITHUB_API_TOKEN'
 			);
 		}
 		return null;
@@ -67,12 +67,12 @@ 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>;
 
@@ -87,18 +87,18 @@ 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;
+	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 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,
+		log
 	});
 	if (!fetched.ok) {
 		// TODO @many this is messy but I think it's the main case we need to worry about?
@@ -123,5 +123,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.js';
+import { ensure_end } from '@fuzdev/fuz_util/string.ts';
 
-import type {GithubPullRequest} from './github.js';
-import type {Repo} from './repo.svelte.js';
+import type { GithubPullRequest } from './github.ts';
+import type { Repo } from './repo.svelte.ts';
 
 export type FilterPullRequest = (pull_request: GithubPullRequest, repo: Repo) => boolean;
 
@@ -12,7 +12,7 @@ export interface PullRequestMeta {
 
 export const to_pull_requests = (
 	repos: Array<Repo>,
-	filter_pull_request?: FilterPullRequest,
+	filter_pull_request?: FilterPullRequest
 ): Array<PullRequestMeta> =>
 	repos
 		.flatMap((repo) => {
@@ -21,8 +21,8 @@ export const to_pull_requests = (
 			return repo.pull_requests.map((pull_request) =>
 				repo.package_json.homepage &&
 				(!filter_pull_request || filter_pull_request(pull_request, repo))
-					? {repo, pull_request}
-					: null,
+					? { repo, pull_request }
+					: null
 			);
 		})
 		.filter((v) => v !== null);

package/src/lib/gitops_analyze.task.ts

@@ -1,42 +1,42 @@
-import type {Task} from '@fuzdev/gro';
-import {z} from 'zod';
-import {styleText as st} from 'node:util';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
+import type { Task } from '@fuzdev/gro';
+import { z } from 'zod';
+import { styleText as st } from 'node:util';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
 
-import {get_gitops_ready} from './gitops_task_helpers.js';
-import type {DependencyGraph} from './dependency_graph.js';
-import type {LocalRepo} from './local_repo.js';
-import {analyze_repos, type DependencyAnalysis} from './graph_validation.js';
+import { get_gitops_ready } from './gitops_task_helpers.ts';
+import type { DependencyGraph } from './dependency_graph.ts';
+import { repo_is_npm } from './local_repo.ts';
+import { analyze_repos, type DependencyAnalysis } from './graph_validation.ts';
 import {
 	format_wildcard_dependencies,
 	format_dev_cycles,
-	format_production_cycles,
-} from './log_helpers.js';
-import {format_and_output, type OutputFormatters} from './output_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
+	format_production_cycles
+} from './log_helpers.ts';
+import { format_and_output, type OutputFormatters } from './output_helpers.ts';
+import { GITOPS_CONFIG_PATH_DEFAULT } from './gitops_constants.ts';
 
 /** @nodocs */
 export const Args = z.strictObject({
 	config: z
 		.string()
-		.meta({description: 'path to the gitops config file, absolute or relative to the cwd'})
+		.meta({ description: 'path to the gitops config file, absolute or relative to the cwd' })
 		.default(GITOPS_CONFIG_PATH_DEFAULT),
 	dir: z
 		.string()
-		.meta({description: 'path containing the repos, defaults to the parent of the config dir'})
+		.meta({ description: 'path containing the repos, defaults to the parent of the config dir' })
 		.optional(),
 	format: z
 		.enum(['stdout', 'json', 'markdown'])
-		.meta({description: 'output format'})
+		.meta({ description: 'output format' })
 		.default('stdout'),
-	outfile: z.string().meta({description: 'write output to file instead of logging'}).optional(),
+	outfile: z.string().meta({ description: 'write output to file instead of logging' }).optional(),
 	sync: z
 		.boolean()
 		.meta({
 			description:
-				'sync repos (switch branch, pull, install) before analyzing instead of reading the working tree as-is',
+				'sync repos (switch branch, pull, install) before analyzing instead of reading the working tree as-is'
 		})
-		.default(false),
+		.default(false)
 });
 export type Args = z.infer<typeof Args>;
 
@@ -44,30 +44,41 @@ export type Args = z.infer<typeof Args>;
 export const task: Task<Args> = {
 	Args,
 	summary: 'analyze dependency structure and relationships across repos',
-	run: async ({args, log}) => {
-		const {config, dir, format, outfile, sync} = args;
+	run: async ({ args, log }) => {
+		const { config, dir, format, outfile, sync } = args;
 
 		// Get repos ready (without downloading); read the working tree as-is unless `--sync`
-		const {local_repos} = await get_gitops_ready({config, dir, download: false, sync, log});
+		const { local_repos } = await get_gitops_ready({ config, dir, download: false, sync, log });
+
+		// Only npm packages form the dependency graph; note any non-npm repos (e.g. cargo)
+		// that are excluded so the omission isn't silent.
+		const non_npm_repos = local_repos.filter((r) => !repo_is_npm(r));
+		if (non_npm_repos.length > 0) {
+			log.info(
+				st(
+					'dim',
+					`excluding ${non_npm_repos.length} non-npm repo(s) from analysis (dashboard-only): ` +
+						non_npm_repos.map((r) => r.library.name).join(', ')
+				)
+			);
+		}
 
 		// Build the dependency graph and analyze cycles/wildcards (tolerating cycles)
-		const {graph, analysis, publishing_order} = analyze_repos(local_repos);
+		const { graph, analysis, publishing_order } = analyze_repos(local_repos);
 
 		// Format and output using output_helpers
 		const data = {
-			repos: local_repos,
 			graph,
 			analysis,
-			publishing_order,
+			publishing_order
 		};
 
-		await format_and_output(data, create_formatters(), {format, outfile, log});
-	},
+		await format_and_output(data, create_formatters(), { format, outfile, log });
+	}
 };
 
 // Data type for analysis output
 interface AnalysisData {
-	repos: Array<LocalRepo>;
 	graph: DependencyGraph;
 	analysis: DependencyAnalysis;
 	publishing_order: Array<string> | null;
@@ -76,51 +87,49 @@ interface AnalysisData {
 // Create formatters for output_helpers
 const create_formatters = (): OutputFormatters<AnalysisData> => ({
 	json: (data) => format_json(data.graph, data.analysis, data.publishing_order),
-	markdown: (data) => format_markdown(data.repos, data.graph, data.analysis, data.publishing_order),
-	stdout: (data, log) =>
-		format_stdout(data.repos, data.graph, data.analysis, data.publishing_order, log),
+	markdown: (data) => format_markdown(data.graph, data.analysis, data.publishing_order),
+	stdout: (data, log) => format_stdout(data.graph, data.analysis, data.publishing_order, log)
 });
 
 // Helper to calculate common statistics
 const calculate_stats = (graph: DependencyGraph) => {
 	const total_deps = Array.from(graph.nodes.values()).reduce(
 		(sum, node) => sum + node.dependencies.size,
-		0,
+		0
 	);
 	const internal_deps = Array.from(graph.nodes.values()).reduce(
 		(sum, node) =>
 			sum + Array.from(node.dependencies.keys()).filter((name) => graph.nodes.has(name)).length,
-		0,
+		0
 	);
-	return {total_deps, internal_deps};
+	return { total_deps, internal_deps };
 };
 
 const format_json = (
 	graph: DependencyGraph,
 	analysis: DependencyAnalysis,
-	publishing_order: Array<string> | null,
+	publishing_order: Array<string> | null
 ): string => {
 	const output = {
 		graph: graph.toJSON(),
 		analysis,
-		publishing_order,
+		publishing_order
 	};
 	return JSON.stringify(output, null, 2);
 };
 
 const format_markdown = (
-	repos: Array<LocalRepo>,
 	graph: DependencyGraph,
 	analysis: DependencyAnalysis,
-	publishing_order: Array<string> | null,
+	publishing_order: Array<string> | null
 ): Array<string> => {
 	const lines: Array<string> = ['# Dependency Analysis'];
 
 	// Summary stats
-	const {total_deps, internal_deps} = calculate_stats(graph);
+	const { total_deps, internal_deps } = calculate_stats(graph);
 
 	lines.push('', '## Summary', '');
-	lines.push(`- **Total packages**: ${repos.length}`);
+	lines.push(`- **Total packages**: ${graph.nodes.size}`);
 	lines.push(`- **Total dependencies**: ${total_deps}`);
 	lines.push(`- **Internal dependencies**: ${internal_deps}`);
 	lines.push(`- **Wildcard dependencies**: ${analysis.wildcard_deps.length}`);
@@ -161,7 +170,7 @@ const format_markdown = (
 		lines.push('', '## ⚠️ Wildcard Dependencies', '');
 		lines.push('| Package | Dependency | Version |');
 		lines.push('|---------|------------|---------|');
-		for (const {pkg, dep, version} of analysis.wildcard_deps) {
+		for (const { pkg, dep, version } of analysis.wildcard_deps) {
 			lines.push(`| \`${pkg}\` | \`${dep}\` | \`${version}\` |`);
 		}
 	}
@@ -170,7 +179,7 @@ const format_markdown = (
 	lines.push('', '## Internal Dependencies', '');
 	for (const node of graph.nodes.values()) {
 		const internal_deps = Array.from(node.dependencies.entries()).filter(([name]) =>
-			graph.nodes.has(name),
+			graph.nodes.has(name)
 		);
 		if (internal_deps.length > 0) {
 			lines.push(`- **${node.name}**`);
@@ -185,13 +194,12 @@ const format_markdown = (
 };
 
 const format_stdout = (
-	repos: Array<LocalRepo>,
 	graph: DependencyGraph,
 	analysis: DependencyAnalysis,
 	publishing_order: Array<string> | null,
-	log: Logger,
+	log: Logger
 ): void => {
-	log.info(st('cyan', `📊 Analyzing ${repos.length} repositories...`));
+	log.info(st('cyan', `📊 Analyzing ${graph.nodes.size} repositories...`));
 
 	// Publishing order
 	if (publishing_order) {
@@ -208,14 +216,14 @@ const format_stdout = (
 	log.info(st('yellow', 'Dependency relationships:'));
 	for (const node of graph.nodes.values()) {
 		const internal_deps = Array.from(node.dependencies.entries()).filter(([name]) =>
-			graph.nodes.has(name),
+			graph.nodes.has(name)
 		);
 		if (internal_deps.length > 0) {
 			log.info(`  ${st('cyan', node.name)}`);
 			for (const [dep_name, spec] of internal_deps) {
 				const type_color = spec.type === 'peer' ? 'magenta' : spec.type === 'dev' ? 'dim' : 'white';
 				log.info(
-					`    ${st(type_color, '→')} ${dep_name} ${st('dim', `(${spec.type}: ${spec.version})`)}`,
+					`    ${st(type_color, '→')} ${dep_name} ${st('dim', `(${spec.type}: ${spec.version})`)}`
 				);
 			}
 		}
@@ -244,11 +252,11 @@ const format_stdout = (
 	}
 
 	// Summary
-	const {total_deps, internal_deps} = calculate_stats(graph);
+	const { total_deps, internal_deps } = calculate_stats(graph);
 
 	log.info('');
 	log.info(st('cyan', 'Summary:'));
-	log.info(`  Total packages: ${repos.length}`);
+	log.info(`  Total packages: ${graph.nodes.size}`);
 	log.info(`  Total dependencies: ${total_deps}`);
 	log.info(`  Internal dependencies: ${internal_deps}`);
 	log.info(`  Wildcard dependencies: ${analysis.wildcard_deps.length}`);

package/src/lib/gitops_config.ts

@@ -11,12 +11,12 @@
  * @module
  */
 
-import type {Url} from '@fuzdev/fuz_util/url.js';
-import {existsSync} from 'node:fs';
-import {strip_end} from '@fuzdev/fuz_util/string.js';
-import type {GitBranch} from '@fuzdev/fuz_util/git.js';
+import type { Url } from '@fuzdev/fuz_util/url.ts';
+import { existsSync } from 'node:fs';
+import { strip_end } from '@fuzdev/fuz_util/string.ts';
+import type { GitBranch } from '@fuzdev/fuz_util/git.ts';
 
-import {DEFAULT_REPOS_DIR} from './paths.js';
+import { DEFAULT_REPOS_DIR } from './paths.ts';
 
 export interface GitopsConfig {
 	repos: Array<GitopsRepoConfig>;
@@ -24,7 +24,7 @@ export interface GitopsConfig {
 }
 
 export type CreateGitopsConfig = (
-	base_config: GitopsConfig,
+	base_config: GitopsConfig
 ) => RawGitopsConfig | Promise<RawGitopsConfig>;
 
 export interface RawGitopsConfig {
@@ -99,7 +99,7 @@ export interface RawGitopsRepoConfig {
 
 export const create_empty_gitops_config = (): GitopsConfig => ({
 	repos: [],
-	repos_dir: DEFAULT_REPOS_DIR,
+	repos_dir: DEFAULT_REPOS_DIR
 });
 
 /**
@@ -110,11 +110,11 @@ export const normalize_gitops_config = (raw_config: RawGitopsConfig): GitopsConf
 	const empty_config = create_empty_gitops_config();
 	// All of the raw config properties are optional,
 	// so fall back to the empty values when `undefined`.
-	const {repos, repos_dir} = raw_config;
+	const { repos, repos_dir } = raw_config;
 	return {
 		repos: repos ? repos.map((r) => parse_fuz_repo_config(r)) : empty_config.repos,
 		// Default to two dirs up from config if not specified
-		repos_dir: repos_dir ?? DEFAULT_REPOS_DIR,
+		repos_dir: repos_dir ?? DEFAULT_REPOS_DIR
 	};
 };
 
@@ -126,7 +126,7 @@ const parse_fuz_repo_config = (r: Url | RawGitopsRepoConfig): GitopsRepoConfig =
 			branch: 'main' as GitBranch, // TODO @zts use flavored for GitBranch
 			visibility: 'public',
 			ci: true,
-			archived: false,
+			archived: false
 		};
 	}
 	const visibility = r.visibility ?? 'public';
@@ -136,7 +136,7 @@ const parse_fuz_repo_config = (r: Url | RawGitopsRepoConfig): GitopsRepoConfig =
 		branch: r.branch ?? ('main' as GitBranch), // TODO @zts use flavored for GitBranch
 		visibility,
 		ci: r.ci ?? visibility === 'public',
-		archived: r.archived ?? false,
+		archived: r.archived ?? false
 	};
 };
 
@@ -155,20 +155,20 @@ export const load_gitops_config = async (config_path: string): Promise<GitopsCon
 	return normalize_gitops_config(
 		typeof config_module.default === 'function'
 			? await config_module.default(create_empty_gitops_config())
-			: config_module.default,
+			: config_module.default
 	);
 };
 
 export const validate_gitops_config_module: (
 	config_module: any,
-	config_path: string,
+	config_path: string
 ) => asserts config_module is GitopsConfigModule = (config_module, config_path) => {
 	const config = config_module.default;
 	if (!config) {
 		throw Error(`Invalid Fuz config module at ${config_path}: expected a default export`);
 	} else if (!(typeof config === 'function' || typeof config === 'object')) {
 		throw Error(
-			`Invalid Fuz config module at ${config_path}: the default export must be a function or object`,
+			`Invalid Fuz config module at ${config_path}: the default export must be a function or object`
 		);
 	}
 };