@fuzdev/fuz_gitops 0.57.0

package/dist/operations_defaults.js

@@ -0,0 +1,279 @@
+/**
+ * Production implementations of operations interfaces.
+ *
+ * Provides real git, npm, fs, and build operations for production use.
+ * For interface definitions and dependency injection pattern, see `operations.ts`.
+ */
+import { spawn, spawn_out } from '@fuzdev/fuz_util/process.js';
+import { readFile, writeFile } from 'node:fs/promises';
+import { git_checkout } from '@fuzdev/fuz_util/git.js';
+import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.js';
+import { has_changesets, read_changesets, predict_next_version } from './changeset_reader.js';
+import { wait_for_package, check_package_available } from './npm_registry.js';
+import { run_preflight_checks } from './preflight_checks.js';
+import { git_add, git_commit, git_add_and_commit, git_tag, git_push_tag, git_has_changes, git_get_changed_files, git_has_file_changed, git_stash, git_stash_pop, git_switch_branch, git_current_branch_name_required, git_current_commit_hash_required, git_check_clean_workspace_as_boolean, git_has_remote, } from './git_operations.js';
+/** Wrap an async function that returns a value */
+const wrap_with_value = async (fn) => {
+    try {
+        const value = await fn();
+        return { ok: true, value };
+    }
+    catch (error) {
+        return { ok: false, message: String(error) };
+    }
+};
+/** Wrap an async function, ignoring its return value */
+const wrap_void = async (fn) => {
+    try {
+        await fn();
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, message: String(error) };
+    }
+};
+export const default_changeset_operations = {
+    has_changesets: async (options) => {
+        const { repo } = options;
+        return wrap_with_value(() => has_changesets(repo));
+    },
+    read_changesets: async (options) => {
+        const { repo, log } = options;
+        return wrap_with_value(() => read_changesets(repo, log));
+    },
+    predict_next_version: async (options) => {
+        const { repo, log } = options;
+        try {
+            const result = await predict_next_version(repo, log);
+            if (result === null) {
+                return null;
+            }
+            return { ok: true, ...result };
+        }
+        catch (error) {
+            return { ok: false, message: String(error) };
+        }
+    },
+};
+export const default_git_operations = {
+    // Core git info
+    current_branch_name: async (options) => {
+        const { cwd } = options ?? EMPTY_OBJECT;
+        return wrap_with_value(() => git_current_branch_name_required(cwd ? { cwd } : undefined));
+    },
+    current_commit_hash: async (options) => {
+        const { branch, cwd } = options ?? EMPTY_OBJECT;
+        return wrap_with_value(() => git_current_commit_hash_required(branch, cwd ? { cwd } : undefined));
+    },
+    check_clean_workspace: async (options) => {
+        const { cwd } = options ?? EMPTY_OBJECT;
+        return wrap_with_value(() => git_check_clean_workspace_as_boolean(cwd ? { cwd } : undefined));
+    },
+    // Branch operations
+    checkout: async (options) => {
+        const { branch, cwd } = options;
+        return wrap_void(() => git_checkout(branch, cwd ? { cwd } : undefined));
+    },
+    pull: async (options) => {
+        const { origin, branch, cwd } = options ?? EMPTY_OBJECT;
+        return wrap_void(() => spawn('git', ['pull', origin || 'origin', branch || ''], cwd ? { cwd } : undefined));
+    },
+    switch_branch: async (options) => {
+        const { branch, pull, cwd } = options;
+        return wrap_void(() => git_switch_branch(branch, pull, cwd ? { cwd } : undefined));
+    },
+    has_remote: async (options) => {
+        const { remote, cwd } = options ?? EMPTY_OBJECT;
+        return wrap_with_value(() => git_has_remote(remote, cwd ? { cwd } : undefined));
+    },
+    // Staging and committing
+    add: async (options) => {
+        const { files, cwd } = options;
+        return wrap_void(() => git_add(files, cwd ? { cwd } : undefined));
+    },
+    commit: async (options) => {
+        const { message, cwd } = options;
+        return wrap_void(() => git_commit(message, cwd ? { cwd } : undefined));
+    },
+    add_and_commit: async (options) => {
+        const { files, message, cwd } = options;
+        return wrap_void(() => git_add_and_commit(files, message, cwd ? { cwd } : undefined));
+    },
+    has_changes: async (options) => {
+        const { cwd } = options ?? EMPTY_OBJECT;
+        return wrap_with_value(() => git_has_changes(cwd ? { cwd } : undefined));
+    },
+    get_changed_files: async (options) => {
+        const { cwd } = options ?? EMPTY_OBJECT;
+        return wrap_with_value(() => git_get_changed_files(cwd ? { cwd } : undefined));
+    },
+    // Tagging
+    tag: async (options) => {
+        const { tag_name, message, cwd } = options;
+        return wrap_void(() => git_tag(tag_name, message, cwd ? { cwd } : undefined));
+    },
+    push_tag: async (options) => {
+        const { tag_name, origin, cwd } = options;
+        return wrap_void(() => git_push_tag(tag_name, origin, cwd ? { cwd } : undefined));
+    },
+    // Stashing
+    stash: async (options) => {
+        const { message, cwd } = options ?? EMPTY_OBJECT;
+        return wrap_void(() => git_stash(message, cwd ? { cwd } : undefined));
+    },
+    stash_pop: async (options) => {
+        const { cwd } = options ?? EMPTY_OBJECT;
+        return wrap_void(() => git_stash_pop(cwd ? { cwd } : undefined));
+    },
+    // File change detection
+    has_file_changed: async (options) => {
+        const { from_commit, to_commit, file_path, cwd } = options;
+        return wrap_with_value(() => git_has_file_changed(from_commit, to_commit, file_path, cwd ? { cwd } : undefined));
+    },
+};
+export const default_process_operations = {
+    spawn: async (options) => {
+        const { cmd, args, spawn_options } = options;
+        try {
+            const spawned = await spawn_out(cmd, args, spawn_options);
+            if (spawned.result.ok) {
+                return {
+                    ok: true,
+                    stdout: spawned.stdout || undefined,
+                    stderr: spawned.stderr || undefined,
+                };
+            }
+            else {
+                return {
+                    ok: false,
+                    message: 'Command failed',
+                    stderr: spawned.stderr || undefined,
+                };
+            }
+        }
+        catch (error) {
+            return { ok: false, message: String(error) };
+        }
+    },
+};
+export const default_npm_operations = {
+    wait_for_package: async (options) => {
+        const { pkg, version, wait_options, log } = options;
+        try {
+            await wait_for_package(pkg, version, { ...wait_options, log });
+            return { ok: true };
+        }
+        catch (error) {
+            return { ok: false, message: String(error), timeout: true };
+        }
+    },
+    check_package_available: async (options) => {
+        const { pkg, version, log } = options;
+        return wrap_with_value(() => check_package_available(pkg, version, { log }));
+    },
+    check_auth: async () => {
+        try {
+            const result = await spawn_out('npm', ['whoami']);
+            if (result.stdout) {
+                const username = result.stdout.trim();
+                if (username) {
+                    return { ok: true, username };
+                }
+            }
+            return { ok: false, message: 'Not logged in to npm' };
+        }
+        catch (error) {
+            return { ok: false, message: String(error) };
+        }
+    },
+    check_registry: async () => {
+        try {
+            const result = await spawn_out('npm', ['ping']);
+            if (result.stdout) {
+                return { ok: true };
+            }
+            return { ok: false, message: 'Failed to ping npm registry' };
+        }
+        catch (error) {
+            return { ok: false, message: String(error) };
+        }
+    },
+    install: async (options) => {
+        const { cwd } = options ?? EMPTY_OBJECT;
+        try {
+            const spawned = await spawn_out('npm', ['install'], cwd ? { cwd } : undefined);
+            if (spawned.result.ok) {
+                return { ok: true };
+            }
+            else {
+                return { ok: false, message: 'Install failed', stderr: spawned.stderr || undefined };
+            }
+        }
+        catch (error) {
+            return { ok: false, message: String(error) };
+        }
+    },
+    cache_clean: async () => {
+        try {
+            const spawned = await spawn_out('npm', ['cache', 'clean', '--force']);
+            if (spawned.result.ok) {
+                return { ok: true };
+            }
+            else {
+                return { ok: false, message: 'Cache clean failed' };
+            }
+        }
+        catch (error) {
+            return { ok: false, message: String(error) };
+        }
+    },
+};
+export const default_preflight_operations = {
+    run_preflight_checks: async (options) => {
+        return run_preflight_checks(options);
+    },
+};
+export const default_fs_operations = {
+    readFile: async (options) => {
+        const { path, encoding } = options;
+        return wrap_with_value(() => readFile(path, encoding));
+    },
+    writeFile: async (options) => {
+        const { path, content } = options;
+        return wrap_void(() => writeFile(path, content));
+    },
+};
+export const default_build_operations = {
+    build_package: async (options) => {
+        const { repo, log } = options;
+        try {
+            log?.info(`  Building ${repo.library.name}...`);
+            const spawned = await spawn_out('gro', ['build'], { cwd: repo.repo_dir });
+            if (spawned.result.ok) {
+                return { ok: true };
+            }
+            else {
+                return {
+                    ok: false,
+                    message: 'Build failed',
+                    output: spawned.stderr || spawned.stdout || 'Build failed',
+                };
+            }
+        }
+        catch (error) {
+            return { ok: false, message: String(error) };
+        }
+    },
+};
+/**
+ * Combined default operations for all gitops functionality.
+ */
+export const default_gitops_operations = {
+    changeset: default_changeset_operations,
+    git: default_git_operations,
+    process: default_process_operations,
+    npm: default_npm_operations,
+    preflight: default_preflight_operations,
+    fs: default_fs_operations,
+    build: default_build_operations,
+};

package/dist/output_helpers.d.ts

@@ -0,0 +1,27 @@
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+export type OutputFormat = 'stdout' | 'json' | 'markdown';
+export interface OutputOptions {
+    format: OutputFormat;
+    outfile?: string;
+    log?: Logger;
+}
+export interface OutputFormatters<T> {
+    json: (data: T) => string;
+    markdown: (data: T) => Array<string>;
+    /**
+     * This function should call log methods directly for colored/styled output.
+     */
+    stdout: (data: T, log: Logger) => void;
+}
+/**
+ * Formats data and outputs to file or stdout based on options.
+ *
+ * Supports three formats:
+ * - stdout: Uses logger for colored/styled output (cannot use with --outfile)
+ * - json: Stringified JSON
+ * - markdown: Formatted markdown text
+ *
+ * @throws {Error} if stdout format used with outfile, or if logger missing for stdout
+ */
+export declare const format_and_output: <T>(data: T, formatters: OutputFormatters<T>, options: OutputOptions) => Promise<void>;
+//# sourceMappingURL=output_helpers.d.ts.map

package/dist/output_helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"output_helpers.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/output_helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAGpD,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,MAAM,GAAG,UAAU,CAAC;AAE1D,MAAM,WAAW,aAAa;IAC7B,MAAM,EAAE,YAAY,CAAC;IACrB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,gBAAgB,CAAC,CAAC;IAClC,IAAI,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;IAC1B,QAAQ,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC;;OAEG;IACH,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACvC;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAU,CAAC,EACxC,MAAM,CAAC,EACP,YAAY,gBAAgB,CAAC,CAAC,CAAC,EAC/B,SAAS,aAAa,KACpB,OAAO,CAAC,IAAI,CA6Bd,CAAC"}

package/dist/output_helpers.js

@@ -0,0 +1,39 @@
+import { writeFile } from 'node:fs/promises';
+/**
+ * Formats data and outputs to file or stdout based on options.
+ *
+ * Supports three formats:
+ * - stdout: Uses logger for colored/styled output (cannot use with --outfile)
+ * - json: Stringified JSON
+ * - markdown: Formatted markdown text
+ *
+ * @throws {Error} if stdout format used with outfile, or if logger missing for stdout
+ */
+export const format_and_output = async (data, formatters, options) => {
+    const { format, outfile, log } = options;
+    // Handle stdout format (special case - uses logger directly)
+    if (format === 'stdout') {
+        if (outfile) {
+            throw new Error('--outfile is not supported with stdout format, use json or markdown');
+        }
+        if (!log) {
+            throw new Error('Logger is required for stdout format');
+        }
+        formatters.stdout(data, log);
+        return;
+    }
+    // Format data
+    const content = format === 'json' ? formatters.json(data) : formatters.markdown(data).join('\n');
+    // Output to file or log
+    if (outfile) {
+        await writeFile(outfile, content);
+        log?.info(`Output written to ${outfile}`);
+    }
+    else {
+        // Log line by line for better formatting
+        const lines = content.split('\n');
+        for (const line of lines) {
+            log?.info(line);
+        }
+    }
+};

package/dist/paths.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Base directory for all gitops-generated files.
+ */
+export declare const GITOPS_OUTPUT_DIR = ".gro/fuz_gitops";
+/**
+ * Default repos directory relative to gitops config file.
+ * Resolves to the parent of the directory with the config
+ * (e.g., ~/dev/repo/gitops.config.ts resolves to ~/dev/).
+ */
+export declare const DEFAULT_REPOS_DIR = "..";
+//# sourceMappingURL=paths.d.ts.map

package/dist/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/paths.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,eAAO,MAAM,iBAAiB,oBAAoB,CAAC;AAEnD;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,OAAO,CAAC"}

package/dist/paths.js

@@ -0,0 +1,10 @@
+/**
+ * Base directory for all gitops-generated files.
+ */
+export const GITOPS_OUTPUT_DIR = '.gro/fuz_gitops';
+/**
+ * Default repos directory relative to gitops config file.
+ * Resolves to the parent of the directory with the config
+ * (e.g., ~/dev/repo/gitops.config.ts resolves to ~/dev/).
+ */
+export const DEFAULT_REPOS_DIR = '..';

package/dist/preflight_checks.d.ts

@@ -0,0 +1,47 @@
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { LocalRepo } from './local_repo.js';
+import type { GitOperations, NpmOperations, BuildOperations, ChangesetOperations } from './operations.js';
+export interface PreflightOptions {
+    skip_changesets?: boolean;
+    skip_build_validation?: boolean;
+    required_branch?: string;
+    check_remote?: boolean;
+    estimate_time?: boolean;
+    log?: Logger;
+}
+export interface PreflightResult {
+    ok: boolean;
+    warnings: Array<string>;
+    errors: Array<string>;
+    repos_with_changesets: Set<string>;
+    repos_without_changesets: Set<string>;
+    estimated_duration?: number;
+    npm_username?: string;
+}
+export interface RunPreflightChecksOptions {
+    repos: Array<LocalRepo>;
+    preflight_options?: PreflightOptions;
+    git_ops?: GitOperations;
+    npm_ops?: NpmOperations;
+    build_ops?: BuildOperations;
+    changeset_ops?: ChangesetOperations;
+}
+/**
+ * Validates all requirements before publishing can proceed.
+ *
+ * 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
+ *
+ * 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
+ */
+export declare const run_preflight_checks: ({ repos, preflight_options, git_ops, npm_ops, build_ops, changeset_ops, }: RunPreflightChecksOptions) => Promise<PreflightResult>;
+//# sourceMappingURL=preflight_checks.d.ts.map

package/dist/preflight_checks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preflight_checks.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/preflight_checks.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAKpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EACX,aAAa,EACb,aAAa,EACb,eAAe,EACf,mBAAmB,EACnB,MAAM,iBAAiB,CAAC;AAQzB,MAAM,WAAW,gBAAgB;IAChC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,GAAG,CAAC,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,QAAQ,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACxB,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACtB,qBAAqB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACnC,wBAAwB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACtC,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,yBAAyB;IACzC,KAAK,EAAE,KAAK,CAAC,SAAS,CAAC,CAAC;IACxB,iBAAiB,CAAC,EAAE,gBAAgB,CAAC;IACrC,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,SAAS,CAAC,EAAE,eAAe,CAAC;IAC5B,aAAa,CAAC,EAAE,mBAAmB,CAAC;CACpC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,oBAAoB,GAAU,2EAOxC,yBAAyB,KAAG,OAAO,CAAC,eAAe,CAwLrD,CAAC"}

package/dist/preflight_checks.js

@@ -0,0 +1,181 @@
+import { spawn_out } from '@fuzdev/fuz_util/process.js';
+import { styleText as st } from 'node:util';
+import { default_git_operations, default_npm_operations, default_build_operations, default_changeset_operations, } from './operations_defaults.js';
+/**
+ * Validates all requirements before publishing can proceed.
+ *
+ * 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
+ *
+ * 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
+ */
+export const run_preflight_checks = async ({ repos, preflight_options = {}, git_ops = default_git_operations, npm_ops = default_npm_operations, build_ops = default_build_operations, changeset_ops = default_changeset_operations, }) => {
+    const { skip_changesets = false, skip_build_validation = false, required_branch = 'main', check_remote = true, estimate_time = true, log, } = preflight_options;
+    const warnings = [];
+    const errors = [];
+    const repos_with_changesets = new Set();
+    const repos_without_changesets = new Set();
+    let npm_username;
+    let estimated_duration;
+    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 }); // eslint-disable-line no-await-in-loop
+        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.get_changed_files({ cwd: repo.repo_dir }); // eslint-disable-line no-await-in-loop
+            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 }); // eslint-disable-line no-await-in-loop
+        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 }); // eslint-disable-line no-await-in-loop
+            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`));
+        }
+    }
+    // 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));
+        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}...`));
+            const build_result = await build_ops.build_package({ repo, log }); // eslint-disable-line no-await-in-loop
+            if (!build_result.ok) {
+                errors.push(`${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'))) {
+            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
+    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'}`);
+    }
+    else {
+        npm_username = npm_auth_result.username;
+        log?.info(st('dim', `    Logged in as: ${npm_username}`));
+    }
+    // 7. 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;
+    if (errors.length > 0) {
+        log?.error(st('red', `\n❌ Preflight checks failed with ${errors.length} errors:`));
+        for (const error of errors) {
+            log?.error(`  - ${error}`);
+        }
+    }
+    if (warnings.length > 0) {
+        log?.warn(st('yellow', `\n⚠️  Preflight checks found ${warnings.length} warnings:`));
+        for (const warning of warnings) {
+            log?.warn(`  - ${warning}`);
+        }
+    }
+    if (ok) {
+        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) => {
+    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) };
+    }
+};