@fuzdev/fuz_gitops 0.77.0 → 0.78.1

package/src/lib/gitops_plan.task.ts

@@ -1,40 +1,40 @@
-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.js';
+import { get_gitops_ready } from './gitops_task_helpers.ts';
 import {
 	generate_publishing_plan,
 	log_publishing_plan,
 	type PublishingPlan,
-	type LogPlanOptions,
-} from './publishing_plan.js';
-import {format_and_output, type OutputFormatters} from './output_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
+	type LogPlanOptions
+} from './publishing_plan.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(),
-	verbose: z.boolean().meta({description: 'show additional details'}).default(false),
+	outfile: z.string().meta({ description: 'write output to file instead of logging' }).optional(),
+	verbose: z.boolean().meta({ description: 'show additional details' }).default(false),
 	sync: z
 		.boolean()
 		.meta({
 			description:
-				'sync repos (switch branch, pull, install) before planning instead of reading the working tree as-is',
+				'sync repos (switch branch, pull, install) before planning instead of reading the working tree as-is'
 		})
-		.default(false),
+		.default(false)
 });
 export type Args = z.infer<typeof Args>;
 
@@ -52,18 +52,18 @@ export type Args = z.infer<typeof Args>;
 export const task: Task<Args> = {
 	summary: 'generate a publishing plan based on changesets',
 	Args,
-	run: async ({args, log}): Promise<void> => {
-		const {dir, config, format, outfile, verbose, sync} = args;
+	run: async ({ args, log }): Promise<void> => {
+		const { dir, config, format, outfile, verbose, sync } = args;
 
 		log.info(st('cyan', 'Generating multi-repo publishing plan...'));
 
 		// Load local repos; read the working tree as-is unless `--sync`
-		const {local_repos} = await get_gitops_ready({
+		const { local_repos } = await get_gitops_ready({
 			config,
 			dir,
 			download: false, // Don't download if missing
 			sync,
-			log,
+			log
 		});
 
 		if (local_repos.length === 0) {
@@ -74,20 +74,20 @@ export const task: Task<Args> = {
 		log.info(`  Found ${local_repos.length} local repos`);
 
 		// Generate publishing plan
-		const plan = await generate_publishing_plan(local_repos, {log, verbose});
+		const plan = await generate_publishing_plan(local_repos, { log, verbose });
 
 		// Format and output using output_helpers
-		await format_and_output(plan, create_plan_formatters({verbose}), {format, outfile, log});
+		await format_and_output(plan, create_plan_formatters({ verbose }), { format, outfile, log });
 
 		// Exit with error if there are blocking issues
 		if (plan.errors.length > 0) {
 			throw new Error('Publishing plan found errors that would block publishing');
 		}
-	},
+	}
 };
 
 const create_plan_formatters = (
-	options: LogPlanOptions = {},
+	options: LogPlanOptions = {}
 ): OutputFormatters<PublishingPlan> => ({
 	json: (plan) => {
 		const output = {
@@ -97,12 +97,12 @@ const create_plan_formatters = (
 			breaking_cascades: Object.fromEntries(plan.breaking_cascades),
 			warnings: plan.warnings,
 			info: plan.info,
-			errors: plan.errors,
+			errors: plan.errors
 		};
 		return JSON.stringify(output, null, 2);
 	},
 	markdown: (plan) => format_plan_as_markdown(plan),
-	stdout: (plan, log) => log_publishing_plan(plan, log, options),
+	stdout: (plan, log) => log_publishing_plan(plan, log, options)
 });
 
 const format_plan_as_markdown = (plan: PublishingPlan): Array<string> => {
@@ -114,7 +114,7 @@ const format_plan_as_markdown = (plan: PublishingPlan): Array<string> => {
 		breaking_cascades,
 		warnings,
 		info,
-		errors,
+		errors
 	} = plan;
 
 	lines.push('# Publishing Plan');
@@ -141,7 +141,7 @@ const format_plan_as_markdown = (plan: PublishingPlan): Array<string> => {
 	// Version changes
 	if (version_changes.length > 0) {
 		const with_changesets = version_changes.filter(
-			(vc) => vc.has_changesets && !vc.needs_bump_escalation,
+			(vc) => vc.has_changesets && !vc.needs_bump_escalation
 		);
 		const with_escalation = version_changes.filter((vc) => vc.needs_bump_escalation);
 		const with_auto_changesets = version_changes.filter((vc) => vc.will_generate_changeset);
@@ -154,7 +154,7 @@ const format_plan_as_markdown = (plan: PublishingPlan): Array<string> => {
 			for (const change of with_changesets) {
 				const is_major = change.bump_type === 'major' ? '💥 Yes' : 'No';
 				lines.push(
-					`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.bump_type} | ${is_major} |`,
+					`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.bump_type} | ${is_major} |`
 				);
 			}
 			lines.push('');
@@ -168,12 +168,12 @@ const format_plan_as_markdown = (plan: PublishingPlan): Array<string> => {
 			for (const change of with_escalation) {
 				const is_major = change.bump_type === 'major' ? '💥 Yes' : 'No';
 				lines.push(
-					`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.existing_bump} | ${change.required_bump} | ${is_major} |`,
+					`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.existing_bump} | ${change.required_bump} | ${is_major} |`
 				);
 			}
 			lines.push('');
 			lines.push(
-				'> ⬆️ These packages have changesets, but dependencies require a larger version bump.',
+				'> ⬆️ These packages have changesets, but dependencies require a larger version bump.'
 			);
 			lines.push('');
 		}
@@ -186,7 +186,7 @@ const format_plan_as_markdown = (plan: PublishingPlan): Array<string> => {
 			for (const change of with_auto_changesets) {
 				const is_major = change.bump_type === 'major' ? '💥 Yes' : 'No';
 				lines.push(
-					`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.bump_type} | ${is_major} |`,
+					`| \`${change.package_name}\` | ${change.from} | ${change.to} | ${change.bump_type} | ${is_major} |`
 				);
 			}
 			lines.push('');
@@ -234,7 +234,7 @@ const format_plan_as_markdown = (plan: PublishingPlan): Array<string> => {
 							? 'peer'
 							: 'dev';
 				lines.push(
-					`- "${update.updated_dependency}": "${update.current_version}"  # ${type_label}`,
+					`- "${update.updated_dependency}": "${update.current_version}"  # ${type_label}`
 				);
 				lines.push(`+ "${update.updated_dependency}": "${update.new_version}"  # ${type_label}`);
 			}

package/src/lib/gitops_publish.task.ts

@@ -1,67 +1,70 @@
-import type {Task} from '@fuzdev/gro';
-import type {Logger} from '@fuzdev/fuz_util/log.js';
-import {z} from 'zod';
-import {createInterface} from 'node:readline/promises';
-import {styleText as st} from 'node:util';
+import type { Task } from '@fuzdev/gro';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { z } from 'zod';
+import { createInterface } from 'node:readline/promises';
+import { styleText as st } from 'node:util';
 
-import {get_gitops_ready} from './gitops_task_helpers.js';
+import { get_gitops_ready } from './gitops_task_helpers.ts';
 import {
 	execute_publishing_plan,
 	type PublishingOptions,
-	type PublishingResult,
-} from './multi_repo_publisher.js';
-import {stdout_handler} from './publishing_event_handler.js';
-import {generate_publishing_plan, log_publishing_plan} from './publishing_plan.js';
-import {derive_publish_steps, format_publish_steps, type PublishStep} from './publish_steps.js';
-import {decide_publish_gate, publish_run_failed} from './publish_gate.js';
-import {format_and_output, type OutputFormatters} from './output_helpers.js';
-import {GITOPS_CONFIG_PATH_DEFAULT, GITOPS_NPM_WAIT_TIMEOUT_DEFAULT} from './gitops_constants.js';
+	type PublishingResult
+} from './multi_repo_publisher.ts';
+import { stdout_handler } from './publishing_event_handler.ts';
+import { generate_publishing_plan, log_publishing_plan } from './publishing_plan.ts';
+import { derive_publish_steps, format_publish_steps, type PublishStep } from './publish_steps.ts';
+import { decide_publish_gate, publish_run_failed } from './publish_gate.ts';
+import { format_and_output, type OutputFormatters } from './output_helpers.ts';
+import { GITOPS_CONFIG_PATH_DEFAULT, GITOPS_NPM_WAIT_TIMEOUT_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(),
 	peer_strategy: z
 		.enum(['exact', 'caret', 'tilde'])
-		.meta({description: 'version strategy for peer dependencies'})
+		.meta({ description: 'version strategy for peer dependencies' })
 		.default('caret' as const),
-	wetrun: z.boolean().meta({description: 'actually publish (default is dry run)'}).default(false),
+	wetrun: z.boolean().meta({ description: 'actually publish (default is dry run)' }).default(false),
 	format: z
 		.enum(['stdout', 'json', 'markdown'])
-		.meta({description: 'output format'})
+		.meta({ description: 'output format' })
 		.default('stdout'),
-	deploy: z.boolean().meta({description: 'deploy all repos after publishing'}).default(false),
+	deploy: z.boolean().meta({ description: 'deploy all repos after publishing' }).default(false),
 	plan: z
 		.boolean()
-		.meta({description: 'show the plan and confirm before publishing; --no-plan to skip'})
+		.meta({ description: 'show the plan and confirm before publishing; --no-plan to skip' })
 		.default(true),
 	max_wait: z
 		.number()
-		.meta({description: 'max time to wait for npm propagation in ms'})
+		.meta({ description: 'max time to wait for npm propagation in ms' })
 		.default(GITOPS_NPM_WAIT_TIMEOUT_DEFAULT),
 	emit_json: z
 		.boolean()
-		.meta({description: 'stream structured publishing events as JSON-lines to stdout'})
+		.meta({ description: 'stream structured publishing events as JSON-lines to stdout' })
+		.default(false),
+	outfile: z.string().meta({ description: 'write output to file instead of logging' }).optional(),
+	verbose: z
+		.boolean()
+		.meta({ description: 'show additional details in plan output' })
 		.default(false),
-	outfile: z.string().meta({description: 'write output to file instead of logging'}).optional(),
-	verbose: z.boolean().meta({description: 'show additional details in plan output'}).default(false),
 	sync: z
 		.boolean()
 		.meta({
 			description:
-				'sync repos (switch branch, pull, install) before the dry run instead of reading the working tree as-is; always on for --wetrun',
+				'sync repos (switch branch, pull, install) before the dry run instead of reading the working tree as-is; always on for --wetrun'
 		})
 		.default(false),
 	preview: z
 		.boolean()
-		.meta({description: 'show the ordered side-effects a --wetrun would perform'})
-		.default(false),
+		.meta({ description: 'show the ordered side-effects a --wetrun would perform' })
+		.default(false)
 });
 export type Args = z.infer<typeof Args>;
 
@@ -69,7 +72,7 @@ export type Args = z.infer<typeof Args>;
 export const task: Task<Args> = {
 	summary: 'publish all repos in dependency order',
 	Args,
-	run: async ({args, log}): Promise<void> => {
+	run: async ({ args, log }): Promise<void> => {
 		const {
 			config,
 			dir,
@@ -83,32 +86,32 @@ export const task: Task<Args> = {
 			outfile,
 			verbose,
 			sync,
-			preview,
+			preview
 		} = args;
 
 		// Load repos. A dry run reads the working tree as-is unless `--sync`;
 		// a real publish (`--wetrun`) always syncs so preflight sees the canonical branches.
-		const {local_repos: repos} = await get_gitops_ready({
+		const { local_repos: repos } = await get_gitops_ready({
 			config,
 			dir,
 			download: false, // Don't download if missing
 			sync: sync || wetrun,
-			log,
+			log
 		});
 
 		// Generate the plan once; the executor consumes this exact plan (no second pass).
-		const publishing_plan = await generate_publishing_plan(repos, {verbose});
-		const preview_steps = preview ? derive_publish_steps(publishing_plan, {deploy}) : null;
+		const publishing_plan = await generate_publishing_plan(repos, { verbose });
+		const preview_steps = preview ? derive_publish_steps(publishing_plan, { deploy }) : null;
 
 		// Decide whether to show the plan + confirm, block, or proceed (the decision table lives
 		// in `decide_publish_gate`; readline + exit stay here at the edge).
-		const gate = decide_publish_gate({wetrun, show_plan: plan, plan: publishing_plan});
+		const gate = decide_publish_gate({ wetrun, show_plan: plan, plan: publishing_plan });
 
 		// A real publish that shows its plan prints it first — including before a `blocked` throw,
 		// so the operator sees the errors that blocked it.
 		if (gate.action !== 'proceed') {
 			log.info(st('cyan', 'Publishing Plan'));
-			log_publishing_plan(publishing_plan, log, {verbose});
+			log_publishing_plan(publishing_plan, log, { verbose });
 		}
 
 		if (gate.action === 'blocked') {
@@ -139,7 +142,7 @@ export const task: Task<Args> = {
 			max_wait,
 			log,
 			// Live JSON-lines stream when requested; events also surface on the result.
-			events: emit_json ? stdout_handler() : undefined,
+			events: emit_json ? stdout_handler() : undefined
 		};
 
 		// Execute publishing (may throw on fatal errors like circular dependencies)
@@ -155,22 +158,22 @@ export const task: Task<Args> = {
 				ok: false,
 				published: [],
 				// Note: FATAL_ERROR is a placeholder - only fatal_error.message is displayed in output
-				failed: [{name: 'FATAL_ERROR', error: fatal_error}],
+				failed: [{ name: 'FATAL_ERROR', error: fatal_error }],
 				duration: 0,
 				events: [],
-				summary: {total: 0, published: 0, failed: 1, skipped: 0, duration: 0},
+				summary: { total: 0, published: 0, failed: 1, skipped: 0, duration: 0 },
 				plan_errors: publishing_plan.errors,
-				plan_warnings: publishing_plan.warnings,
+				plan_warnings: publishing_plan.warnings
 			};
 		}
 
 		// Format and output result (always runs, even on fatal errors)
 		// Note: stdout format is handled by the executor's logging
 		if (format !== 'stdout') {
-			await format_and_output({result, fatal_error, preview_steps}, create_publish_formatters(), {
+			await format_and_output({ result, fatal_error, preview_steps }, create_publish_formatters(), {
 				format,
 				outfile,
-				log,
+				log
 			});
 		}
 
@@ -178,7 +181,7 @@ export const task: Task<Args> = {
 		if (publish_run_failed(result, fatal_error)) {
 			process.exit(1);
 		}
-	},
+	}
 };
 
 interface PublishResultData {
@@ -190,15 +193,15 @@ interface PublishResultData {
 const create_publish_formatters = (): OutputFormatters<PublishResultData> => ({
 	json: (data) =>
 		JSON.stringify(
-			data.preview_steps ? {...data.result, preview: data.preview_steps} : data.result,
+			data.preview_steps ? { ...data.result, preview: data.preview_steps } : data.result,
 			null,
-			2,
+			2
 		),
 	markdown: (data) => format_result_markdown(data.result, data.fatal_error, data.preview_steps),
 	stdout: () => {
 		// stdout format is handled by the executor's logging
 		// This should never be called due to early return in task
-	},
+	}
 });
 
 /** Logs the ordered side-effect preview to stdout. */
@@ -213,7 +216,7 @@ const log_preview = (steps: Array<PublishStep>, log: Logger): void => {
 const format_result_markdown = (
 	result: PublishingResult,
 	fatal_error: Error | null,
-	preview_steps: Array<PublishStep> | null,
+	preview_steps: Array<PublishStep> | null
 ): Array<string> => {
 	const lines: Array<string> = [];
 
@@ -252,7 +255,7 @@ const format_result_markdown = (
 		lines.push('');
 		lines.push('## Failed Packages');
 		lines.push('');
-		for (const {name, error} of result.failed) {
+		for (const { name, error } of result.failed) {
 			lines.push(`- \`${name}\`: ${error.message}`);
 		}
 	}
@@ -290,7 +293,7 @@ const format_result_markdown = (
 const prompt_for_confirmation = async (): Promise<boolean> => {
 	const rl = createInterface({
 		input: process.stdin,
-		output: process.stdout,
+		output: process.stdout
 	});
 
 	const answer = await rl.question('');

package/src/lib/gitops_run.task.ts

@@ -1,33 +1,33 @@
-import {TaskError, type Task} from '@fuzdev/gro';
-import {z} from 'zod';
-import {map_concurrent_settled} from '@fuzdev/fuz_util/async.js';
-import {spawn_out} from '@fuzdev/fuz_util/process.js';
-import {writeFile} from 'node:fs/promises';
-import {styleText as st} from 'node:util';
-import {resolve} from 'node:path';
+import { TaskError, type Task } from '@fuzdev/gro';
+import { z } from 'zod';
+import { map_concurrent_settled } from '@fuzdev/fuz_util/async.ts';
+import { spawn_out } from '@fuzdev/fuz_util/process.ts';
+import { writeFile } from 'node:fs/promises';
+import { styleText as st } from 'node:util';
+import { resolve } from 'node:path';
 
-import {get_repo_paths} from './repo_ops.js';
-import {GITOPS_CONCURRENCY_DEFAULT, GITOPS_CONFIG_PATH_DEFAULT} from './gitops_constants.js';
+import { get_repo_paths } from './repo_ops.ts';
+import { GITOPS_CONCURRENCY_DEFAULT, GITOPS_CONFIG_PATH_DEFAULT } from './gitops_constants.ts';
 
 export const Args = z.strictObject({
 	// Positional rest args (gro convention) so `gro gitops_run "npm test"` works;
 	// joined with spaces and passed to `sh -c`, so quote commands that contain flags.
-	_: z.array(z.string()).meta({description: 'shell command to run in each repo'}).default([]),
+	_: z.array(z.string()).meta({ description: 'shell command to run in each repo' }).default([]),
 	config: z
 		.string()
-		.meta({description: 'path to the gitops config file'})
+		.meta({ description: 'path to the gitops config file' })
 		.default(GITOPS_CONFIG_PATH_DEFAULT),
 	concurrency: z
 		.number()
 		.int()
 		.min(1)
-		.meta({description: 'maximum number of repos to run in parallel'})
+		.meta({ description: 'maximum number of repos to run in parallel' })
 		.default(GITOPS_CONCURRENCY_DEFAULT),
-	format: z.enum(['text', 'json']).meta({description: 'output format'}).default('text'),
+	format: z.enum(['text', 'json']).meta({ description: 'output format' }).default('text'),
 	outfile: z
 		.string()
-		.meta({description: 'with --format json, write clean JSON to this file instead of stdout'})
-		.optional(),
+		.meta({ description: 'with --format json, write clean JSON to this file instead of stdout' })
+		.optional()
 });
 export type Args = z.infer<typeof Args>;
 
@@ -45,8 +45,8 @@ interface RunResult {
 export const task: Task<Args> = {
 	Args,
 	summary: 'run a shell command across all repos in parallel',
-	run: async ({args, log}) => {
-		const {_, config, concurrency, format, outfile} = args;
+	run: async ({ args, log }) => {
+		const { _, config, concurrency, format, outfile } = args;
 
 		const command = _.join(' ').trim();
 		if (!command) {
@@ -62,7 +62,7 @@ export const task: Task<Args> = {
 		}
 
 		log.info(
-			`Running ${st('cyan', command)} across ${repos.length} repos (concurrency: ${concurrency})`,
+			`Running ${st('cyan', command)} across ${repos.length} repos (concurrency: ${concurrency})`
 		);
 
 		const start_time = performance.now();
@@ -77,7 +77,7 @@ export const task: Task<Args> = {
 				// Parse command into cmd + args for spawn
 				// For now, we use shell mode to support pipes/redirects/etc
 				const spawned = await spawn_out('sh', ['-c', command], {
-					cwd: repo_dir,
+					cwd: repo_dir
 				});
 
 				const duration_ms = performance.now() - repo_start;
@@ -90,7 +90,7 @@ export const task: Task<Args> = {
 					exit_code: spawned.result.kind === 'exited' ? spawned.result.code : 0,
 					stdout: spawned.stdout || '',
 					stderr: spawned.stderr || '',
-					duration_ms,
+					duration_ms
 				};
 
 				return result;
@@ -104,7 +104,7 @@ export const task: Task<Args> = {
 					stdout: '',
 					stderr: '',
 					duration_ms,
-					error: String(error),
+					error: String(error)
 				};
 			}
 		});
@@ -134,7 +134,7 @@ export const task: Task<Args> = {
 					stdout: '',
 					stderr: '',
 					duration_ms: 0,
-					error: String(result.reason),
+					error: String(result.reason)
 				});
 			}
 		}
@@ -149,8 +149,8 @@ export const task: Task<Args> = {
 					total: repos.length,
 					success: successes.length,
 					failure: failures.length,
-					duration_ms: Math.round(total_duration_ms),
-				},
+					duration_ms: Math.round(total_duration_ms)
+				}
 			};
 			const json = JSON.stringify(json_output, null, 2);
 			if (outfile) {
@@ -225,15 +225,15 @@ export const task: Task<Args> = {
 				log.info(
 					st(
 						'green',
-						`✓ All ${total} repos succeeded in ${duration} (${success_rate}% success rate)`,
-					),
+						`✓ All ${total} repos succeeded in ${duration} (${success_rate}% success rate)`
+					)
 				);
 			} else {
 				log.info(
 					st(
 						'yellow',
-						`⚠ ${successes.length}/${total} repos succeeded in ${duration} (${success_rate}% success rate)`,
-					),
+						`⚠ ${successes.length}/${total} repos succeeded in ${duration} (${success_rate}% success rate)`
+					)
 				);
 			}
 		}
@@ -242,5 +242,5 @@ export const task: Task<Args> = {
 		if (failures.length > 0) {
 			throw new TaskError(`${failures.length} repos failed`);
 		}
-	},
+	}
 };