@fuzdev/fuz_gitops 0.78.0 → 0.78.1

package/src/lib/gitops_validate.task.ts

@@ -1,37 +1,37 @@
-import type {Task} from '@fuzdev/gro';
-import {z} from 'zod';
-import {styleText as st} from 'node:util';
+import type { Task } from '@fuzdev/gro';
+import { z } from 'zod';
+import { styleText as st } from 'node:util';
 
-import {get_gitops_ready} from './gitops_task_helpers.ts';
-import {analyze_repos, type DependencyAnalysis} from './graph_validation.ts';
+import { get_gitops_ready } from './gitops_task_helpers.ts';
+import { analyze_repos, type DependencyAnalysis } from './graph_validation.ts';
 import {
 	generate_publishing_plan,
 	log_publishing_plan,
-	type PublishingPlan,
+	type PublishingPlan
 } from './publishing_plan.ts';
-import {execute_publishing_plan, type PublishingOptions} from './multi_repo_publisher.ts';
-import {log_dependency_analysis} from './log_helpers.ts';
-import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.ts';
-import {reconcile_ci, repo_has_workflows} from './ci_reconcile.ts';
+import { execute_publishing_plan, type PublishingOptions } from './multi_repo_publisher.ts';
+import { log_dependency_analysis } from './log_helpers.ts';
+import { GITOPS_CONFIG_PATH_DEFAULT } from './gitops_constants.ts';
+import { reconcile_ci, repo_has_workflows } from './ci_reconcile.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(),
-	verbose: z.boolean().meta({description: 'show additional details'}).default(false),
+	verbose: z.boolean().meta({ description: 'show additional details' }).default(false),
 	sync: z
 		.boolean()
 		.meta({
 			description:
-				'sync repos (switch branch, pull, install) before validating instead of reading the working tree as-is',
+				'sync repos (switch branch, pull, install) before validating instead of reading the working tree as-is'
 		})
-		.default(false),
+		.default(false)
 });
 export type Args = z.infer<typeof Args>;
 
@@ -40,8 +40,8 @@ export const task: Task<Args> = {
 	Args,
 	summary:
 		'validate gitops configuration by running all read-only commands and checking for issues',
-	run: async ({args, log}) => {
-		const {config, dir, verbose, sync} = args;
+	run: async ({ args, log }) => {
+		const { config, dir, verbose, sync } = args;
 
 		log.info(st('cyan', 'Running Gitops Validation Suite'));
 		log.info(st('dim', 'This runs all read-only commands and checks for consistency.'));
@@ -61,7 +61,7 @@ export const task: Task<Args> = {
 
 		// Load repos once (shared by all commands); read the working tree as-is unless `--sync`
 		log.info(st('dim', 'Loading repositories...'));
-		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 });
 		log.info(st('dim', `   Found ${local_repos.length} local repos`));
 
 		// 1. Run gitops_analyze
@@ -69,7 +69,7 @@ export const task: Task<Args> = {
 		const analyze_start = Date.now();
 		try {
 			// Build dependency graph and analyze cycles/wildcards (tolerating cycles)
-			const {analysis} = analyze_repos(local_repos);
+			const { analysis } = analyze_repos(local_repos);
 
 			const analyze_duration = Date.now() - analyze_start;
 
@@ -93,7 +93,7 @@ export const task: Task<Args> = {
 				duration: analyze_duration,
 				warning_details,
 				info_details,
-				analysis,
+				analysis
 			});
 
 			log.info(st('green', `  ✓ gitops_analyze completed in ${analyze_duration}ms`));
@@ -111,7 +111,7 @@ export const task: Task<Args> = {
 				success: false,
 				warnings: 0,
 				errors: 1,
-				duration: analyze_duration,
+				duration: analyze_duration
 			});
 			log.error(st('red', `  ✗ gitops_analyze failed: ${error}`));
 		}
@@ -121,7 +121,7 @@ export const task: Task<Args> = {
 		log.info(st('yellow', 'Running gitops_plan...'));
 		const plan_start = Date.now();
 		try {
-			const plan = await generate_publishing_plan(local_repos, {verbose});
+			const plan = await generate_publishing_plan(local_repos, { verbose });
 			publishing_plan = plan;
 			const plan_duration = Date.now() - plan_start;
 
@@ -133,12 +133,12 @@ export const task: Task<Args> = {
 				success: errors === 0,
 				warnings,
 				errors,
-				duration: plan_duration,
+				duration: plan_duration
 			});
 
 			log.info(st('green', `  ✓ gitops_plan completed in ${plan_duration}ms`));
 			if (verbose) {
-				log_publishing_plan(plan, log, {verbose});
+				log_publishing_plan(plan, log, { verbose });
 			}
 			if (warnings > 0) {
 				log.warn(st('yellow', `  ⚠️  Found ${warnings} warning(s)`));
@@ -153,7 +153,7 @@ export const task: Task<Args> = {
 				success: false,
 				warnings: 0,
 				errors: 1,
-				duration: plan_duration,
+				duration: plan_duration
 			});
 			log.error(st('red', `  ✗ gitops_plan failed: ${error}`));
 		}
@@ -164,14 +164,14 @@ export const task: Task<Args> = {
 		try {
 			const options: PublishingOptions = {
 				wetrun: false,
-				log: undefined, // Silent for validation
+				log: undefined // Silent for validation
 			};
 
 			// Reuse the plan from step 2 (regenerate only if that step failed to produce one).
 			const result = await execute_publishing_plan(
 				local_repos,
-				publishing_plan ?? (await generate_publishing_plan(local_repos, {verbose})),
-				options,
+				publishing_plan ?? (await generate_publishing_plan(local_repos, { verbose })),
+				options
 			);
 			const dry_duration = Date.now() - dry_start;
 
@@ -184,7 +184,7 @@ export const task: Task<Args> = {
 				success: result.ok,
 				warnings: 0,
 				errors,
-				duration: dry_duration,
+				duration: dry_duration
 			});
 
 			log.info(st('green', `  ✓ gitops_publish (dry run) completed in ${dry_duration}ms`));
@@ -198,7 +198,7 @@ export const task: Task<Args> = {
 				success: false,
 				warnings: 0,
 				errors: 1,
-				duration: dry_duration,
+				duration: dry_duration
 			});
 			log.error(st('red', `  ✗ gitops_publish (dry run) failed: ${error}`));
 		}
@@ -217,21 +217,21 @@ export const task: Task<Args> = {
 					// always `true` today. The gate exists for a future caller that loads a
 					// partial set; until then the skip path is inert and untested.
 					checkable: true,
-					archived: r.repo_config.archived,
-				})),
+					archived: r.repo_config.archived
+				}))
 			);
 			const ci_duration = Date.now() - ci_start;
 			const drift_details = ci_drift.map((d) =>
 				d.kind === 'missing_ci'
 					? `${d.repo_url}: ci=true but no workflow files`
-					: `${d.repo_url}: ci=false but workflow files present`,
+					: `${d.repo_url}: ci=false but workflow files present`
 			);
 			results.push({
 				command: 'ci_reconcile',
 				success: ci_drift.length === 0,
 				warnings: 0,
 				errors: ci_drift.length,
-				duration: ci_duration,
+				duration: ci_duration
 			});
 			if (ci_drift.length === 0) {
 				log.info(st('green', `  ✓ ci_reconcile completed in ${ci_duration}ms`));
@@ -248,7 +248,7 @@ export const task: Task<Args> = {
 				success: false,
 				warnings: 0,
 				errors: 1,
-				duration: ci_duration,
+				duration: ci_duration
 			});
 			log.error(st('red', `  ✗ ci_reconcile failed: ${error}`));
 		}
@@ -295,7 +295,7 @@ export const task: Task<Args> = {
 			log.info(st('green', '✓ All validation checks passed'));
 			if (total_warnings > 0) {
 				log.warn(
-					st('yellow', `⚠️  Note: ${total_warnings} warning(s) found - review output above.`),
+					st('yellow', `⚠️  Note: ${total_warnings} warning(s) found - review output above.`)
 				);
 			}
 		} else {
@@ -305,5 +305,5 @@ export const task: Task<Args> = {
 			log.error(st('red', '❌ Validation failed - review the errors above.'));
 			throw new Error('Validation failed');
 		}
-	},
+	}
 };

package/src/lib/graph_validation.ts

@@ -13,12 +13,12 @@
  * @module
  */
 
-import type {Logger} from '@fuzdev/fuz_util/log.ts';
-import {TaskError} from '@fuzdev/gro';
-import {styleText as st} from 'node:util';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { TaskError } from '@fuzdev/gro';
+import { styleText as st } from 'node:util';
 
-import {DependencyGraph, DependencyGraphBuilder} from './dependency_graph.ts';
-import {repo_is_npm, type LocalRepo} from './local_repo.ts';
+import { DependencyGraph, DependencyGraphBuilder } from './dependency_graph.ts';
+import { repo_is_npm, type LocalRepo } from './local_repo.ts';
 
 export interface GraphValidationResult {
 	graph: DependencyGraph;
@@ -45,9 +45,9 @@ export const validate_dependency_graph = (
 		throw_on_prod_cycles?: boolean;
 		log_cycles?: boolean;
 		log_order?: boolean;
-	} = {},
+	} = {}
 ): GraphValidationResult => {
-	const {log, throw_on_prod_cycles = true, log_cycles = true, log_order = true} = options;
+	const { log, throw_on_prod_cycles = true, log_cycles = true, log_order = true } = options;
 
 	// Build dependency graph
 	log?.info('📊 Analyzing dependencies...');
@@ -55,7 +55,7 @@ export const validate_dependency_graph = (
 	const graph = builder.build_from_repos(repos);
 
 	// Check for cycles
-	const {production_cycles, dev_cycles} = graph.detect_cycles_by_type();
+	const { production_cycles, dev_cycles } = graph.detect_cycles_by_type();
 
 	// Log production cycles
 	if (production_cycles.length > 0 && log_cycles) {
@@ -67,7 +67,7 @@ export const validate_dependency_graph = (
 		if (throw_on_prod_cycles) {
 			throw new TaskError(
 				`Cannot publish with production/peer dependency cycles. ` +
-					`These must be resolved before publishing.`,
+					`These must be resolved before publishing.`
 			);
 		}
 	}
@@ -106,7 +106,7 @@ export const validate_dependency_graph = (
 		publishing_order,
 		production_cycles,
 		dev_cycles,
-		sort_error,
+		sort_error
 	};
 };
 
@@ -128,11 +128,11 @@ export interface RepoAnalysis {
  */
 export const analyze_repos = (repos: Array<LocalRepo>): RepoAnalysis => {
 	// Only npm packages form the dependency graph; non-npm repos (e.g. cargo) are excluded.
-	const {graph, publishing_order: order} = validate_dependency_graph(repos.filter(repo_is_npm), {
+	const { graph, publishing_order: order } = validate_dependency_graph(repos.filter(repo_is_npm), {
 		throw_on_prod_cycles: false, // report, don't throw
 		log_cycles: false, // callers format their own cycle output
-		log_order: false,
+		log_order: false
 	});
 	const analysis = new DependencyGraphBuilder().analyze(graph);
-	return {graph, analysis, publishing_order: order.length > 0 ? order : null};
+	return { graph, analysis, publishing_order: order.length > 0 ? order : null };
 };

package/src/lib/local_repo.ts

@@ -1,22 +1,22 @@
-import {strip_end} from '@fuzdev/fuz_util/string.ts';
-import {to_error_message} from '@fuzdev/fuz_util/error.ts';
-import {library_json_from_modules, type LibraryJson} from '@fuzdev/fuz_util/library_json.ts';
-import type {PackageJson} from '@fuzdev/fuz_util/package_json.ts';
-import {Library} from '@fuzdev/fuz_ui/library.svelte.ts';
-import {existsSync} from 'node:fs';
-import {join} from 'node:path';
-import {TaskError} from '@fuzdev/gro';
-import {library_load_from_repo} from '@fuzdev/gro/library_load.ts';
-import type {Logger} from '@fuzdev/fuz_util/log.ts';
-import {spawn_out} from '@fuzdev/fuz_util/process.ts';
-import {map_concurrent_settled} from '@fuzdev/fuz_util/async.ts';
-import type {GitOperations, NpmOperations} from './operations.ts';
-import {default_git_operations, default_npm_operations} from './operations_defaults.ts';
-
-import type {GitopsConfig, GitopsRepoConfig} from './gitops_config.ts';
-import type {ResolvedGitopsConfig} from './resolved_gitops_config.ts';
-import {GITOPS_CONCURRENCY_DEFAULT} from './gitops_constants.ts';
-import {cargo_toml_load} from './cargo_toml.ts';
+import { strip_end } from '@fuzdev/fuz_util/string.ts';
+import { to_error_message } from '@fuzdev/fuz_util/error.ts';
+import { library_json_from_modules, type LibraryJson } from '@fuzdev/fuz_util/library_json.ts';
+import type { PackageJson } from '@fuzdev/fuz_util/package_json.ts';
+import { Library } from '@fuzdev/fuz_ui/library.svelte.ts';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { TaskError } from '@fuzdev/gro';
+import { library_load_from_repo } from '@fuzdev/gro/library_load.ts';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { spawn_out } from '@fuzdev/fuz_util/process.ts';
+import { map_concurrent_settled } from '@fuzdev/fuz_util/async.ts';
+import type { GitOperations, NpmOperations } from './operations.ts';
+import { default_git_operations, default_npm_operations } from './operations_defaults.ts';
+
+import type { GitopsConfig, GitopsRepoConfig } from './gitops_config.ts';
+import type { ResolvedGitopsConfig } from './resolved_gitops_config.ts';
+import { GITOPS_CONCURRENCY_DEFAULT } from './gitops_constants.ts';
+import { cargo_toml_load } from './cargo_toml.ts';
 
 /**
  * Fully loaded local repo with `Library` and extracted dependency data.
@@ -97,7 +97,7 @@ export const local_repo_load = async ({
 	git_ops = default_git_operations,
 	npm_ops = default_npm_operations,
 	sync = true,
-	allow_dirty = false,
+	allow_dirty = false
 }: {
 	local_repo_path: LocalRepoPath;
 	log?: Logger;
@@ -106,20 +106,20 @@ export const local_repo_load = async ({
 	sync?: boolean;
 	allow_dirty?: boolean;
 }): Promise<LocalRepo> => {
-	const {repo_config, repo_dir, repo_name, repo_git_ssh_url} = local_repo_path;
+	const { repo_config, repo_dir, repo_name, repo_git_ssh_url } = local_repo_path;
 
 	if (sync) {
 		// Record commit hash before any changes
-		const commit_before_result = await git_ops.current_commit_hash({cwd: repo_dir});
+		const commit_before_result = await git_ops.current_commit_hash({ cwd: repo_dir });
 		if (!commit_before_result.ok) {
 			throw new TaskError(
-				`Failed to get commit hash in ${repo_dir}: ${commit_before_result.message}`,
+				`Failed to get commit hash in ${repo_dir}: ${commit_before_result.message}`
 			);
 		}
 		const commit_before = commit_before_result.value;
 
 		// Switch to target branch if needed
-		const branch_result = await git_ops.current_branch_name({cwd: repo_dir});
+		const branch_result = await git_ops.current_branch_name({ cwd: repo_dir });
 		if (!branch_result.ok) {
 			throw new TaskError(`Failed to get current branch in ${repo_dir}: ${branch_result.message}`);
 		}
@@ -129,28 +129,28 @@ export const local_repo_load = async ({
 			// Guard the switch on a clean workspace unless the caller opts into `allow_dirty`,
 			// in which case we let `git checkout` itself fail loudly if it can't proceed.
 			if (!allow_dirty) {
-				const clean_result = await git_ops.check_clean_workspace({cwd: repo_dir});
+				const clean_result = await git_ops.check_clean_workspace({ cwd: repo_dir });
 				if (!clean_result.ok) {
 					throw new TaskError(`Failed to check workspace in ${repo_dir}: ${clean_result.message}`);
 				}
 
 				if (!clean_result.value) {
 					throw new TaskError(
-						`Repo ${repo_dir} is not on branch "${repo_config.branch}" and the workspace is unclean, blocking switch`,
+						`Repo ${repo_dir} is not on branch "${repo_config.branch}" and the workspace is unclean, blocking switch`
 					);
 				}
 			}
 
-			const checkout_result = await git_ops.checkout({branch: repo_config.branch, cwd: repo_dir});
+			const checkout_result = await git_ops.checkout({ branch: repo_config.branch, cwd: repo_dir });
 			if (!checkout_result.ok) {
 				throw new TaskError(
-					`Failed to checkout branch "${repo_config.branch}" in ${repo_dir}: ${checkout_result.message}`,
+					`Failed to checkout branch "${repo_config.branch}" in ${repo_dir}: ${checkout_result.message}`
 				);
 			}
 		}
 
 		// Only pull if remote exists (skip for local-only repos, test fixtures)
-		const origin_result = await git_ops.has_remote({remote: 'origin', cwd: repo_dir});
+		const origin_result = await git_ops.has_remote({ remote: 'origin', cwd: repo_dir });
 		if (!origin_result.ok) {
 			throw new TaskError(`Failed to check for remote in ${repo_dir}: ${origin_result.message}`);
 		}
@@ -159,7 +159,7 @@ export const local_repo_load = async ({
 			// Pull the configured branch explicitly. Without a branch, `git pull origin`
 			// targets the remote's default branch (origin/HEAD), which for a repo checked
 			// out on a non-default branch rebases the wrong branch onto it.
-			const pull_result = await git_ops.pull({branch: repo_config.branch, cwd: repo_dir});
+			const pull_result = await git_ops.pull({ branch: repo_config.branch, cwd: repo_dir });
 			if (!pull_result.ok) {
 				throw new TaskError(`Failed to pull in ${repo_dir}: ${pull_result.message}`);
 			}
@@ -168,25 +168,25 @@ export const local_repo_load = async ({
 		// Check clean workspace after pull to ensure we're in a good state
 		// (skipped when `allow_dirty`, since uncommitted changes are expected then)
 		if (!allow_dirty) {
-			const clean_after_result = await git_ops.check_clean_workspace({cwd: repo_dir});
+			const clean_after_result = await git_ops.check_clean_workspace({ cwd: repo_dir });
 			if (!clean_after_result.ok) {
 				throw new TaskError(
-					`Failed to check workspace in ${repo_dir}: ${clean_after_result.message}`,
+					`Failed to check workspace in ${repo_dir}: ${clean_after_result.message}`
 				);
 			}
 
 			if (!clean_after_result.value) {
 				throw new TaskError(
-					`Workspace ${repo_dir} is unclean after pulling branch "${repo_config.branch}"`,
+					`Workspace ${repo_dir} is unclean after pulling branch "${repo_config.branch}"`
 				);
 			}
 		}
 
 		// Record commit hash after pull
-		const commit_after_result = await git_ops.current_commit_hash({cwd: repo_dir});
+		const commit_after_result = await git_ops.current_commit_hash({ cwd: repo_dir });
 		if (!commit_after_result.ok) {
 			throw new TaskError(
-				`Failed to get commit hash in ${repo_dir}: ${commit_after_result.message}`,
+				`Failed to get commit hash in ${repo_dir}: ${commit_after_result.message}`
 			);
 		}
 		const commit_after = commit_after_result.value;
@@ -200,20 +200,20 @@ export const local_repo_load = async ({
 				from_commit: commit_before,
 				to_commit: commit_after,
 				file_path: 'package.json',
-				cwd: repo_dir,
+				cwd: repo_dir
 			});
 
 			if (!changed_result.ok) {
 				throw new TaskError(
-					`Failed to check if package.json changed in ${repo_dir}: ${changed_result.message}`,
+					`Failed to check if package.json changed in ${repo_dir}: ${changed_result.message}`
 				);
 			}
 
 			if (changed_result.value) {
-				const install_result = await npm_ops.install({cwd: repo_dir});
+				const install_result = await npm_ops.install({ cwd: repo_dir });
 				if (!install_result.ok) {
 					throw new TaskError(
-						`Failed to install dependencies in ${repo_dir}: ${install_result.message}${install_result.stderr ? `\n${install_result.stderr}` : ''}`,
+						`Failed to install dependencies in ${repo_dir}: ${install_result.message}${install_result.stderr ? `\n${install_result.stderr}` : ''}`
 					);
 				}
 			}
@@ -225,21 +225,21 @@ export const local_repo_load = async ({
 	// publishing/analysis skips. Anything else falls through to the npm loader below, whose
 	// error covers a genuinely missing or unreadable manifest.
 	if (!existsSync(join(repo_dir, 'package.json')) && existsSync(join(repo_dir, 'Cargo.toml'))) {
-		return local_repo_load_cargo({local_repo_path});
+		return local_repo_load_cargo({ local_repo_path });
 	}
 
 	// Load library metadata via svelte-docinfo analysis (cached under `.gro/library.json`).
 	let library_json: LibraryJson;
 	let package_json: PackageJson;
 	try {
-		({library_json, package_json} = await library_load_from_repo(repo_dir, {log: _log}));
+		({ library_json, package_json } = await library_load_from_repo(repo_dir, { log: _log }));
 	} catch (err) {
 		const message = to_error_message(err);
 		_log?.warn(
-			`Failed to load library metadata for repo "${repo_name}" in ${repo_dir}: ${message}`,
+			`Failed to load library metadata for repo "${repo_name}" in ${repo_dir}: ${message}`
 		);
 		throw new TaskError(
-			`Failed to load library metadata for repo "${repo_name}" in ${repo_dir}: ${message}`,
+			`Failed to load library metadata for repo "${repo_name}" in ${repo_dir}: ${message}`
 		);
 	}
 	const library = new Library(library_json);
@@ -250,7 +250,7 @@ export const local_repo_load = async ({
 		package_json,
 		repo_dir,
 		repo_git_ssh_url,
-		repo_config,
+		repo_config
 	};
 
 	// Extract dependencies from the full package_json
@@ -284,11 +284,11 @@ export const repo_is_npm = (repo: LocalRepo): boolean => repo.kind === 'npm';
  * analysis paths skip it (see `repo_is_npm`).
  */
 const local_repo_load_cargo = async ({
-	local_repo_path,
+	local_repo_path
 }: {
 	local_repo_path: LocalRepoPath;
 }): Promise<LocalRepo> => {
-	const {repo_config, repo_dir, repo_name, repo_url, repo_git_ssh_url} = local_repo_path;
+	const { repo_config, repo_dir, repo_name, repo_url, repo_git_ssh_url } = local_repo_path;
 
 	const cargo = await cargo_toml_load(repo_dir);
 
@@ -299,7 +299,7 @@ const local_repo_load_cargo = async ({
 		version: cargo?.version ?? '0.0.0',
 		repository: cargo?.repository ?? repo_url,
 		private: true,
-		...(cargo?.description ? {description: cargo.description} : null),
+		...(cargo?.description ? { description: cargo.description } : null)
 	};
 
 	const library = new Library(library_json_from_modules(package_json, []));
@@ -310,7 +310,7 @@ const local_repo_load_cargo = async ({
 		package_json,
 		repo_dir,
 		repo_git_ssh_url,
-		repo_config,
+		repo_config
 	};
 };
 
@@ -320,7 +320,7 @@ export const local_repos_ensure = async ({
 	gitops_config,
 	download,
 	log,
-	npm_ops = default_npm_operations,
+	npm_ops = default_npm_operations
 }: {
 	resolved_config: ResolvedGitopsConfig;
 	repos_dir: string;
@@ -339,19 +339,19 @@ export const local_repos_ensure = async ({
 				repos_dir,
 				local_repos_missing: resolved_config.local_repos_missing,
 				log,
-				npm_ops,
+				npm_ops
 			});
 			local_repo_paths = (resolved_config.local_repo_paths ?? [])
 				.concat(downloaded)
 				.sort(
 					(a, b) =>
 						gitops_config.repos.findIndex((r) => r.repo_url === a.repo_url) -
-						gitops_config.repos.findIndex((r) => r.repo_url === b.repo_url),
+						gitops_config.repos.findIndex((r) => r.repo_url === b.repo_url)
 				);
 		} else {
 			log?.error(
 				`Failed to resolve local repos in ${repos_dir} - do you need to pass \`--download\` or configure the directory?`, // TODO leaking task impl details
-				resolved_config.local_repos_missing.map((r) => r.repo_url),
+				resolved_config.local_repos_missing.map((r) => r.repo_url)
 			);
 			throw new TaskError('Failed to resolve local configs');
 		}
@@ -372,7 +372,7 @@ export const local_repos_load = async ({
 	parallel = true,
 	concurrency = GITOPS_CONCURRENCY_DEFAULT,
 	sync = true,
-	allow_dirty = false,
+	allow_dirty = false
 }: {
 	local_repo_paths: Array<LocalRepoPath>;
 	log?: Logger;
@@ -388,7 +388,7 @@ export const local_repos_load = async ({
 		const loaded: Array<LocalRepo> = [];
 		for (const local_repo_path of local_repo_paths) {
 			loaded.push(
-				await local_repo_load({local_repo_path, log, git_ops, npm_ops, sync, allow_dirty}),
+				await local_repo_load({ local_repo_path, log, git_ops, npm_ops, sync, allow_dirty })
 			);
 		}
 		return loaded;
@@ -399,13 +399,13 @@ export const local_repos_load = async ({
 		local_repo_paths,
 		concurrency,
 		async (local_repo_path) => {
-			return local_repo_load({local_repo_path, log, git_ops, npm_ops, sync, allow_dirty});
-		},
+			return local_repo_load({ local_repo_path, log, git_ops, npm_ops, sync, allow_dirty });
+		}
 	);
 
 	// Check for failures and collect successes
 	const loaded: Array<LocalRepo> = [];
-	const errors: Array<{repo_name: string; error: string}> = [];
+	const errors: Array<{ repo_name: string; error: string }> = [];
 
 	for (let i = 0; i < results.length; i++) {
 		const result = results[i]!;
@@ -415,7 +415,7 @@ export const local_repos_load = async ({
 			const repo_path = local_repo_paths[i]!;
 			errors.push({
 				repo_name: repo_path.repo_name,
-				error: String(result.reason),
+				error: String(result.reason)
 			});
 		}
 	}
@@ -431,12 +431,12 @@ export const local_repos_load = async ({
 
 export const local_repo_locate = ({
 	repo_config,
-	repos_dir,
+	repos_dir
 }: {
 	repo_config: GitopsRepoConfig;
 	repos_dir: string;
 }): LocalRepoPath | LocalRepoMissing => {
-	const {repo_url} = repo_config;
+	const { repo_url } = repo_config;
 	const repo_name = strip_end(repo_url, '/').split('/').at(-1);
 	if (!repo_name) throw Error('Invalid `repo_config.repo_url` ' + repo_url);
 
@@ -444,7 +444,7 @@ export const local_repo_locate = ({
 
 	const repo_dir = repo_config.repo_dir ?? join(repos_dir, repo_name);
 	if (!existsSync(repo_dir)) {
-		return {type: 'local_repo_missing', repo_name, repo_url, repo_git_ssh_url, repo_config};
+		return { type: 'local_repo_missing', repo_name, repo_url, repo_git_ssh_url, repo_config };
 	}
 
 	return {
@@ -453,7 +453,7 @@ export const local_repo_locate = ({
 		repo_dir,
 		repo_url,
 		repo_git_ssh_url,
-		repo_config,
+		repo_config
 	};
 };
 
@@ -466,7 +466,7 @@ const download_repos = async ({
 	repos_dir,
 	local_repos_missing,
 	log,
-	npm_ops = default_npm_operations,
+	npm_ops = default_npm_operations
 }: {
 	repos_dir: string;
 	local_repos_missing: Array<LocalRepoMissing>;
@@ -474,26 +474,26 @@ const download_repos = async ({
 	npm_ops?: NpmOperations;
 }): Promise<Array<LocalRepoPath>> => {
 	const resolved: Array<LocalRepoPath> = [];
-	for (const {repo_config, repo_git_ssh_url} of local_repos_missing) {
+	for (const { repo_config, repo_git_ssh_url } of local_repos_missing) {
 		log?.info(`cloning repo ${repo_git_ssh_url} to ${repos_dir}`);
-		const clone_result = await spawn_out('git', ['clone', repo_git_ssh_url], {cwd: repos_dir});
+		const clone_result = await spawn_out('git', ['clone', repo_git_ssh_url], { cwd: repos_dir });
 		if (!clone_result.result.ok) {
 			throw new TaskError(
-				`Failed to clone repo ${repo_git_ssh_url} to ${repos_dir}${clone_result.stderr ? ': ' + clone_result.stderr.trim() : ''}`,
+				`Failed to clone repo ${repo_git_ssh_url} to ${repos_dir}${clone_result.stderr ? ': ' + clone_result.stderr.trim() : ''}`
 			);
 		}
-		const local_repo = local_repo_locate({repo_config, repos_dir});
+		const local_repo = local_repo_locate({ repo_config, repos_dir });
 		if (local_repo.type === 'local_repo_missing') {
 			throw new TaskError(
-				`Failed to clone repo ${repo_git_ssh_url} to ${repos_dir}: directory not found after clone`,
+				`Failed to clone repo ${repo_git_ssh_url} to ${repos_dir}: directory not found after clone`
 			);
 		}
 		// Always install dependencies after cloning
 		log?.info(`installing dependencies for newly cloned repo ${local_repo.repo_dir}`);
-		const install_result = await npm_ops.install({cwd: local_repo.repo_dir});
+		const install_result = await npm_ops.install({ cwd: local_repo.repo_dir });
 		if (!install_result.ok) {
 			throw new TaskError(
-				`Failed to install dependencies in ${local_repo.repo_dir}: ${install_result.message}${install_result.stderr ? `\n${install_result.stderr}` : ''}`,
+				`Failed to install dependencies in ${local_repo.repo_dir}: ${install_result.message}${install_result.stderr ? `\n${install_result.stderr}` : ''}`
 			);
 		}
 		resolved.push(local_repo);