@fuzdev/fuz_gitops 0.78.0 → 0.79.0

package/src/lib/preflight_checks.ts

@@ -1,228 +1,113 @@
-import type {Logger} from '@fuzdev/fuz_util/log.ts';
-import type {Result} from '@fuzdev/fuz_util/result.ts';
-import {spawn_out} from '@fuzdev/fuz_util/process.ts';
-import {styleText as st} from 'node:util';
+import type { Logger } from '@fuzdev/fuz_util/log.ts';
+import { styleText as st } from 'node:util';
 
-import type {LocalRepo} from './local_repo.ts';
-import type {
-	GitOperations,
-	NpmOperations,
-	BuildOperations,
-	ChangesetOperations,
-} from './operations.ts';
-import {
-	default_git_operations,
-	default_npm_operations,
-	default_build_operations,
-	default_changeset_operations,
-} from './operations_defaults.ts';
-
-export interface PreflightOptions {
-	skip_changesets?: boolean;
-	skip_build_validation?: boolean; // Skip build validation (useful for tests)
-	required_branch?: string;
-	check_remote?: boolean; // Check if git remote is reachable
-	estimate_time?: boolean; // Estimate total publish time
-	log?: Logger;
-}
+import type { LocalRepo } from './local_repo.ts';
+import type { VersionChange } from './publishing_plan.ts';
+import type { NpmOperations, BuildOperations } from './operations.ts';
+import { default_npm_operations, default_build_operations } from './operations_defaults.ts';
 
 export interface PreflightResult {
 	ok: boolean;
 	warnings: Array<string>;
 	errors: Array<string>;
-	repos_with_changesets: Set<string>;
-	repos_without_changesets: Set<string>;
-	estimated_duration?: number; // In seconds
-	npm_username?: string;
 }
 
 export interface RunPreflightChecksOptions {
 	repos: Array<LocalRepo>;
-	preflight_options?: PreflightOptions;
-	git_ops?: GitOperations;
+	/**
+	 * The plan's version changes — every package the run publishes, explicit,
+	 * escalated, and auto-generated alike. Preflight builds exactly these.
+	 */
+	version_changes: Array<VersionChange>;
+	log?: Logger;
 	npm_ops?: NpmOperations;
 	build_ops?: BuildOperations;
-	changeset_ops?: ChangesetOperations;
 }
 
 /**
- * Validates all requirements before publishing can proceed.
+ * Validates the publish-time requirements beyond repo git state:
+ * - every package the plan publishes builds (fail-fast to prevent broken state)
+ * - npm authentication
+ * - npm registry connectivity
  *
- * Performs comprehensive pre-flight validation:
- * - Clean workspaces (100% clean required - no uncommitted changes)
- * - Correct branch (usually main)
- * - Changesets present (unless `skip_changesets`=true)
- * - Builds successful (fail-fast to prevent broken state)
- * - Git remote reachability
- * - NPM authentication with username
- * - NPM registry connectivity
+ * What publishes is the plan's to decide, so preflight reads no changesets: it
+ * builds each package in `version_changes`. Git state — each repo on its
+ * registry branch, clean, idle, in sync with origin or ahead of it, and no live
+ * session in its checkout — is the readiness gate's, which `gitops_publish
+ * --wetrun` runs before the plan's confirmation prompt (`repo_readiness.ts`), so
+ * preflight reads no git.
  *
  * Build validation runs BEFORE any publishing to prevent the scenario where
  * version is bumped but build fails, leaving repo in broken state.
  *
- * @returns result with `ok`=false if any errors, plus warnings and detailed status
+ * @returns result with `ok`=false if any errors, plus warnings
  */
 export const run_preflight_checks = async ({
 	repos,
-	preflight_options = {},
-	git_ops = default_git_operations,
+	version_changes,
+	log,
 	npm_ops = default_npm_operations,
-	build_ops = default_build_operations,
-	changeset_ops = default_changeset_operations,
+	build_ops = default_build_operations
 }: RunPreflightChecksOptions): Promise<PreflightResult> => {
-	const {
-		skip_changesets = false,
-		skip_build_validation = false,
-		required_branch = 'main',
-		check_remote = true,
-		estimate_time = true,
-		log,
-	} = preflight_options;
-
 	const warnings: Array<string> = [];
 	const errors: Array<string> = [];
-	const repos_with_changesets: Set<string> = new Set();
-	const repos_without_changesets: Set<string> = new Set();
-	let npm_username: string | undefined;
-	let estimated_duration: number | undefined;
 
 	log?.info(st('cyan', '✅ Running preflight checks...'));
 
-	// 1. Check clean workspaces - must be 100% clean before publishing
-	log?.info('  Checking workspace cleanliness...');
-	for (const repo of repos) {
-		const clean_result = await git_ops.check_clean_workspace({cwd: repo.repo_dir});
-		if (!clean_result.ok) {
-			errors.push(`${repo.library.name} failed workspace check: ${clean_result.message}`);
-			continue;
-		}
-
-		if (!clean_result.value) {
-			// Get list of changed files for better error message
-			const files_result = await git_ops.list_uncommitted_files({cwd: repo.repo_dir});
-			if (files_result.ok) {
-				// No filtering - workspace must be 100% clean
-				const unexpected_files = files_result.value;
-
-				if (unexpected_files.length > 0) {
-					errors.push(
-						`${repo.library.name} has uncommitted changes in: ${unexpected_files.slice(0, 3).join(', ')}${unexpected_files.length > 3 ? ` and ${unexpected_files.length - 3} more` : ''}`,
-					);
-				}
-			} else {
-				errors.push(`${repo.library.name} has uncommitted changes`);
-			}
-		}
-	}
-
-	// 2. Check correct branch
-	log?.info(`  Checking branches (expecting ${required_branch})...`);
-	for (const repo of repos) {
-		const branch_result = await git_ops.current_branch_name({cwd: repo.repo_dir});
-		if (!branch_result.ok) {
-			errors.push(`${repo.library.name} failed branch check: ${branch_result.message}`);
-			continue;
-		}
-
-		if (branch_result.value !== required_branch) {
-			errors.push(
-				`${repo.library.name} is on branch '${branch_result.value}', expected '${required_branch}'`,
-			);
-		}
-	}
-
-	// 3. Check changesets (unless skipped)
-	if (!skip_changesets) {
-		log?.info('  Checking for changesets...');
-		for (const repo of repos) {
-			const has_result = await changeset_ops.has_changesets({repo});
-			if (!has_result.ok) {
-				errors.push(`${repo.library.name} failed changeset check: ${has_result.message}`);
-				continue;
-			}
-
-			if (has_result.value) {
-				repos_with_changesets.add(repo.library.name);
-			} else {
-				repos_without_changesets.add(repo.library.name);
-				warnings.push(`${repo.library.name} has no changesets`);
-			}
-		}
-
-		if (repos_without_changesets.size > 0) {
-			log?.warn(st('yellow', `  ⚠️  ${repos_without_changesets.size} packages have no changesets`));
+	// 1. Build every package the plan publishes
+	const repo_by_name: Map<string, LocalRepo> = new Map(repos.map((r) => [r.library.name, r]));
+	const repos_to_build: Array<LocalRepo> = [];
+	for (const change of version_changes) {
+		const repo = repo_by_name.get(change.package_name);
+		if (repo) {
+			repos_to_build.push(repo);
+		} else {
+			errors.push(`${change.package_name} is in the plan but not among the repos`);
 		}
 	}
 
-	// 4. Validate builds for packages with changesets
-	if (!skip_build_validation && repos_with_changesets.size > 0) {
-		log?.info(st('cyan', `  Validating builds for ${repos_with_changesets.size} package(s)...`));
-		const repos_to_build = repos.filter((repo) => repos_with_changesets.has(repo.library.name));
-
+	if (repos_to_build.length > 0) {
+		log?.info(st('cyan', `  Validating builds for ${repos_to_build.length} package(s)...`));
+		let build_failures = 0;
 		for (let i = 0; i < repos_to_build.length; i++) {
 			const repo = repos_to_build[i]!;
 			log?.info(
-				st('dim', `    [${i + 1}/${repos_to_build.length}] Building ${repo.library.name}...`),
+				st('dim', `    [${i + 1}/${repos_to_build.length}] Building ${repo.library.name}...`)
 			);
-			const build_result = await build_ops.build_package({repo, log});
-			if (!build_result.ok) {
+			const build_result = await build_ops.build_package({ repo });
+			if (build_result.ok) {
+				log?.info(st('dim', `    ✓ ${repo.library.name} built successfully`));
+			} else {
+				build_failures++;
 				errors.push(
-					`${repo.library.name} failed to build: ${build_result.output || build_result.message || 'unknown error'}`,
+					`${repo.library.name} failed to build: ${build_result.output || build_result.message || 'unknown error'}`
 				);
-			} else {
-				log?.info(st('dim', `    ✓ ${repo.library.name} built successfully`));
 			}
 		}
 
-		if (errors.some((err) => err.includes('failed to build'))) {
+		if (build_failures > 0) {
 			log?.error(st('red', '  ❌ Build validation failed - fix build errors before publishing'));
 		} else {
 			log?.info(st('green', '  ✓ All builds validated successfully'));
 		}
 	}
 
-	// 5. Check git remote reachability (skip in tests when check_remote is false)
-	if (check_remote && repos.length > 0) {
-		log?.info('  Checking git remote connectivity...');
-		// Only check first repo to avoid slowing down tests with multiple remote checks
-		const remote_result = await check_git_remote(repos[0]!.repo_dir);
-		if (!remote_result.ok) {
-			warnings.push(`git remote may not be reachable - ${remote_result.message}`);
-		}
-	}
-
-	// 6. Check npm authentication with username
+	// 2. Check npm authentication
 	log?.info('  Checking npm authentication...');
 	const npm_auth_result = await npm_ops.check_auth();
-	if (!npm_auth_result.ok) {
-		errors.push(`npm authentication failed: ${npm_auth_result.message || 'not logged in'}`);
+	if (npm_auth_result.ok) {
+		log?.info(st('dim', `    Logged in as: ${npm_auth_result.username}`));
 	} else {
-		npm_username = npm_auth_result.username;
-		log?.info(st('dim', `    Logged in as: ${npm_username}`));
+		errors.push(`npm authentication failed: ${npm_auth_result.message || 'not logged in'}`);
 	}
 
-	// 7. Check network connectivity (npm registry)
+	// 3. Check network connectivity (npm registry)
 	log?.info('  Checking npm registry connectivity...');
 	const registry_result = await npm_ops.check_registry();
 	if (!registry_result.ok) {
 		warnings.push(`npm registry check failed: ${registry_result.message}`);
 	}
 
-	// 8. Estimate total publish time
-	if (estimate_time) {
-		const packages_to_publish = repos_with_changesets.size;
-		if (packages_to_publish > 0) {
-			// Rough estimate: 30s per package + 10s per package for NPM propagation
-			estimated_duration = packages_to_publish * 40;
-			log?.info(
-				st(
-					'dim',
-					`  Estimated publish time: ~${Math.ceil(estimated_duration / 60)} minutes for ${packages_to_publish} package(s)`,
-				),
-			);
-		}
-	}
-
 	// Report results
 	const ok = errors.length === 0;
 
@@ -244,26 +129,5 @@ export const run_preflight_checks = async ({
 		log?.info(st('green', '\n✨ All preflight checks passed!'));
 	}
 
-	return {
-		ok,
-		warnings,
-		errors,
-		repos_with_changesets,
-		repos_without_changesets,
-		estimated_duration,
-		npm_username,
-	};
-};
-
-const check_git_remote = async (cwd: string): Promise<Result<object, {message: string}>> => {
-	try {
-		// Try to fetch refs from remote without downloading objects
-		const result = await spawn_out('git', ['ls-remote', '--heads', 'origin'], {cwd});
-		if (result.stdout || result.stderr) {
-			return {ok: true};
-		}
-		return {ok: false, message: 'No response from git remote'};
-	} catch (error) {
-		return {ok: false, message: String(error)};
-	}
+	return { ok, warnings, errors };
 };

package/src/lib/publish_gate.ts

@@ -8,14 +8,12 @@
  * @module
  */
 
-import type {PublishingResult} from './multi_repo_publisher.ts';
-import type {PublishingPlan} from './publishing_plan.ts';
+import type { PublishingResult } from './multi_repo_publisher.ts';
+import type { PublishingPlan } from './publishing_plan.ts';
 
 /** What the task should do with a generated plan before executing the cascade. */
 export type PublishGate =
-	| {action: 'blocked'; message: string}
-	| {action: 'confirm'}
-	| {action: 'proceed'};
+	{ action: 'blocked'; message: string } | { action: 'confirm' } | { action: 'proceed' };
 
 export interface PublishGateOptions {
 	/** A real publish (`--wetrun`); a dry run never prompts. */
@@ -36,11 +34,11 @@ export interface PublishGateOptions {
  * - `proceed`: a dry run, or a `--no-plan` real publish — no prompt.
  */
 export const decide_publish_gate = (options: PublishGateOptions): PublishGate => {
-	if (!options.wetrun || !options.show_plan) return {action: 'proceed'};
+	if (!options.wetrun || !options.show_plan) return { action: 'proceed' };
 	if (options.plan.errors.length > 0) {
-		return {action: 'blocked', message: 'Cannot proceed with publishing due to errors'};
+		return { action: 'blocked', message: 'Cannot proceed with publishing due to errors' };
 	}
-	return {action: 'confirm'};
+	return { action: 'confirm' };
 };
 
 /**
@@ -49,5 +47,5 @@ export const decide_publish_gate = (options: PublishGateOptions): PublishGate =>
  */
 export const publish_run_failed = (
 	result: Pick<PublishingResult, 'ok'>,
-	fatal_error: Error | null,
+	fatal_error: Error | null
 ): boolean => !result.ok || fatal_error !== null;

package/src/lib/publish_steps.ts

@@ -8,17 +8,26 @@
  * @module
  */
 
-import type {BumpType} from './version_utils.ts';
-import type {PublishingPlan, VersionChange} from './publishing_plan.ts';
-import {UnreachableError} from '@fuzdev/fuz_util/error.ts';
-
-/** How a package's version bump arises in the plan. */
-export type PublishStepVia = 'changeset' | 'auto_changeset' | 'escalation';
+import type { BumpType } from './version_utils.ts';
+import {
+	version_change_kind,
+	type PublishingPlan,
+	type VersionChange,
+	type VersionChangeKind
+} from './publishing_plan.ts';
+import { UnreachableError } from '@fuzdev/fuz_util/error.ts';
 
 /** One ordered side-effect a wetrun would perform. */
 export type PublishStep =
-	| {kind: 'publish'; repo: string; from: string; to: string; bump: BumpType; via: PublishStepVia}
-	| {kind: 'npm_wait'; repo: string; version: string}
+	| {
+			kind: 'publish';
+			repo: string;
+			from: string;
+			to: string;
+			bump: BumpType;
+			via: VersionChangeKind;
+	  }
+	| { kind: 'npm_wait'; repo: string; version: string }
 	| {
 			kind: 'dependency_update';
 			dependent: string;
@@ -27,21 +36,14 @@ export type PublishStep =
 			dep_type: 'prod' | 'peer';
 			creates_changeset: boolean;
 	  }
-	| {kind: 'dev_dep_update'; repo: string; dependency: string; to: string}
-	| {kind: 'deploy'; repo: string; builds: boolean};
+	| { kind: 'dev_dep_update'; repo: string; dependency: string; to: string }
+	| { kind: 'deploy'; repo: string; builds: boolean };
 
 export interface DerivePublishStepsOptions {
 	/** Include the deploy phase (the publisher only deploys with `--deploy`). */
 	deploy?: boolean;
 }
 
-const step_via = (change: VersionChange): PublishStepVia =>
-	change.needs_bump_escalation
-		? 'escalation'
-		: change.has_changesets
-			? 'changeset'
-			: 'auto_changeset';
-
 /**
  * Derives the ordered side-effects a wetrun would perform from a frozen plan.
  *
@@ -51,11 +53,11 @@ const step_via = (change: VersionChange): PublishStepVia =>
  */
 export const derive_publish_steps = (
 	plan: PublishingPlan,
-	options: DerivePublishStepsOptions = {},
+	options: DerivePublishStepsOptions = {}
 ): Array<PublishStep> => {
-	const {deploy = false} = options;
+	const { deploy = false } = options;
 	const changes: Map<string, VersionChange> = new Map(
-		plan.version_changes.map((vc) => [vc.package_name, vc]),
+		plan.version_changes.map((vc) => [vc.package_name, vc])
 	);
 
 	const steps: Array<PublishStep> = [];
@@ -72,9 +74,9 @@ export const derive_publish_steps = (
 			from: change.from,
 			to: change.to,
 			bump: change.bump_type,
-			via: step_via(change),
+			via: version_change_kind(change)
 		});
-		steps.push({kind: 'npm_wait', repo, version: change.to});
+		steps.push({ kind: 'npm_wait', repo, version: change.to });
 		changed.add(repo);
 
 		// Prod/peer dependents are rewritten right after this publishes. A dependent that
@@ -92,7 +94,7 @@ export const derive_publish_steps = (
 				dependency: repo,
 				to: change.to,
 				dep_type: update.type === 'peerDependencies' ? 'peer' : 'prod',
-				creates_changeset: republishes,
+				creates_changeset: republishes
 			});
 			changed.add(update.dependent_package);
 		}
@@ -109,7 +111,7 @@ export const derive_publish_steps = (
 			kind: 'dev_dep_update',
 			repo: update.dependent_package,
 			dependency: update.updated_dependency,
-			to: dep_change.to,
+			to: dep_change.to
 		});
 		changed.add(update.dependent_package);
 	}
@@ -117,7 +119,7 @@ export const derive_publish_steps = (
 	// Phase 3: deploy every changed repo (only with --deploy). Each builds fresh.
 	if (deploy) {
 		for (const repo of changed) {
-			steps.push({kind: 'deploy', repo, builds: true});
+			steps.push({ kind: 'deploy', repo, builds: true });
 		}
 	}
 

package/src/lib/publishing_event.ts

@@ -14,33 +14,34 @@
  * @module
  */
 
-import {z} from 'zod';
+import { z } from 'zod';
 
 /**
  * Coarse triage classification for a failed package. Lets consumers branch on
  * failure kind without parsing the message.
  */
 export const PublishingErrorCode = z.enum([
+	// the publish step failed — its cause is in the message, not yet classified further
 	'publish',
+	// the published version never appeared on the npm registry within the wait
 	'network',
-	'auth',
-	'dependency',
-	'build',
 	// the real published version diverged from the frozen plan's prediction — an
 	// invariant violation, distinct from an ordinary publish failure (see fail-loud
 	// drift detection in `multi_repo_publisher.ts`)
 	'drift',
-	'other',
+	// the repo wasn't ready when re-checked right before its `gro publish` (origin moved,
+	// a tracked edit, a live session, …) — aborted before any npm side effect
+	'not_ready'
 ]);
 export type PublishingErrorCode = z.infer<typeof PublishingErrorCode>;
 
 /** Tallied outcome of a publishing run, derived from its events via `summarize_events`. */
 export const PublishingRunSummary = z.strictObject({
-	total: z.number().meta({description: 'packages in the publishing order (the candidate set)'}),
-	published: z.number().meta({description: 'packages published (or, in a dry run, predicted)'}),
+	total: z.number().meta({ description: 'packages in the publishing order (the candidate set)' }),
+	published: z.number().meta({ description: 'packages published (or, in a dry run, predicted)' }),
 	failed: z.number(),
 	skipped: z.number(),
-	duration: z.number().meta({description: 'wall-clock duration in milliseconds'}),
+	duration: z.number().meta({ description: 'wall-clock duration in milliseconds' })
 });
 export type PublishingRunSummary = z.infer<typeof PublishingRunSummary>;
 
@@ -51,13 +52,15 @@ export type PublishingRunSummary = z.infer<typeof PublishingRunSummary>;
 export const PublishingEvent = z.discriminatedUnion('event', [
 	z.strictObject({
 		event: z.literal('run_started'),
-		wetrun: z.boolean().meta({description: 'false means every package_completed is a prediction'}),
-		total: z.number(),
+		wetrun: z
+			.boolean()
+			.meta({ description: 'false means every package_completed is a prediction' }),
+		total: z.number()
 	}),
 	z.strictObject({
 		event: z.literal('package_skipped'),
 		name: z.string(),
-		reason: z.string(),
+		reason: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('package_completed'),
@@ -67,19 +70,19 @@ export const PublishingEvent = z.discriminatedUnion('event', [
 		// mirrors `BumpType` from `version_utils.ts`; inline so the event schema is self-contained
 		bump_type: z.enum(['major', 'minor', 'patch']),
 		breaking: z.boolean(),
-		commit: z.string().meta({description: "'simulated' in a dry run, otherwise the commit hash"}),
-		tag: z.string(),
+		commit: z.string().meta({ description: "'simulated' in a dry run, otherwise the commit hash" }),
+		tag: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('npm_waited'),
 		name: z.string(),
-		version: z.string().meta({description: 'the version waited on after publishing'}),
+		version: z.string().meta({ description: 'the version waited on after publishing' })
 	}),
 	z.strictObject({
 		event: z.literal('package_failed'),
 		name: z.string(),
 		error: z.string(),
-		code: PublishingErrorCode,
+		code: PublishingErrorCode
 	}),
 	z.strictObject({
 		event: z.literal('dependency_updated'),
@@ -91,25 +94,25 @@ export const PublishingEvent = z.discriminatedUnion('event', [
 		dep_type: z.enum(['prod', 'peer', 'dev']),
 		// true when the update creates an auto-changeset (a publishable dependent republishes);
 		// false for dev-dep updates and update-only leaves (private dependents never publish).
-		creates_changeset: z.boolean(),
+		creates_changeset: z.boolean()
 	}),
 	z.strictObject({
 		event: z.literal('deploy_started'),
-		name: z.string(),
+		name: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('deploy_completed'),
-		name: z.string(),
+		name: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('deploy_failed'),
 		name: z.string(),
-		error: z.string(),
+		error: z.string()
 	}),
 	z.strictObject({
 		event: z.literal('run_finished'),
-		summary: PublishingRunSummary,
-	}),
+		summary: PublishingRunSummary
+	})
 ]);
 export type PublishingEvent = z.infer<typeof PublishingEvent>;
 
@@ -123,7 +126,7 @@ export type PublishingEvent = z.infer<typeof PublishingEvent>;
  */
 export const summarize_events = (
 	events: Array<PublishingEvent>,
-	duration: number,
+	duration: number
 ): PublishingRunSummary => {
 	let total = 0;
 	let published = 0;
@@ -147,5 +150,5 @@ export const summarize_events = (
 				break;
 		}
 	}
-	return {total, published, failed, skipped, duration};
+	return { total, published, failed, skipped, duration };
 };