@fuzdev/fuz_gitops 0.78.1 → 0.79.0

package/src/lib/local_repo.ts

@@ -1,22 +1,20 @@
-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 type { Result } from '@fuzdev/fuz_util/result.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_config_leaked_private_repos } from './gitops_config.ts';
+import type { ReposEntryStatus, ReposStatusReport } from './repos_status.ts';
 import { GITOPS_CONCURRENCY_DEFAULT } from './gitops_constants.ts';
 import { cargo_toml_load } from './cargo_toml.ts';
+import { to_repos_command } from './repos_status_load.ts';
 
 /**
  * Fully loaded local repo with `Library` and extracted dependency data.
@@ -35,190 +33,123 @@ export interface LocalRepo {
 	/** The repo's full `package.json` (with `dependencies`/`devDependencies`). */
 	package_json: PackageJson;
 	repo_dir: string;
-	repo_git_ssh_url: string;
-	repo_config: GitopsRepoConfig;
+	/**
+	 * The repo's registry entry as `repos status --json` reported it: its
+	 * `branch`, `visibility`, `ci`, and `archived`, and its git state.
+	 */
+	entry: ReposEntryStatus;
 	dependencies?: Map<string, string>;
 	dev_dependencies?: Map<string, string>;
 	peer_dependencies?: Map<string, string>;
 }
 
 /**
- * A repo that has been located on the filesystem (path exists).
- * Used before loading - just filesystem/git concerns.
+ * A configured repo resolved through `repos status`: present on disk, before
+ * its library is loaded. See `local_repos_resolve`.
  */
 export interface LocalRepoPath {
-	type: 'local_repo_path';
-	repo_name: string; // from URL parsing (for display/logging before Library loaded)
+	/** The repo's registry key (for display/logging before `Library` is loaded). */
+	repo_name: string;
+	/** The workspace root joined with the entry's `dir`. */
 	repo_dir: string;
+	/** The registry's HTTPS URL for the repo. */
 	repo_url: string;
-	repo_git_ssh_url: string;
-	repo_config: GitopsRepoConfig;
+	/** The repo's registry entry as `repos status --json` reported it. */
+	entry: ReposEntryStatus;
 }
 
 /**
- * A repo that is missing from the filesystem (needs cloning).
+ * Resolves a gitops config's registry keys against a `repos status` report,
+ * in config order. Every key must name an owned repo that's present and was
+ * probed; each that doesn't is a problem, and any problem fails the whole
+ * resolve, naming them all.
+ *
+ * @param options.keys - the config's registry keys, in config order
+ * @param options.report - `repos status <keys…> --json`'s report
+ * @param options.host - the package whose generated data the run writes; when public, a private repo is a problem (`gitops_config_leaked_private_repos`)
+ * @param options.registry - the `--registry` the report was made with, repeated in the hints
+ * @returns the repos in config order, or a message listing every problem
  */
-export interface LocalRepoMissing {
-	type: 'local_repo_missing';
-	repo_name: string;
-	repo_url: string;
-	repo_git_ssh_url: string;
-	repo_config: GitopsRepoConfig;
-}
+export const local_repos_resolve = (options: {
+	keys: ReadonlyArray<string>;
+	report: ReposStatusReport;
+	host?: { name: string; private: boolean };
+	registry?: string;
+}): Result<{ value: Array<LocalRepoPath> }, { message: string; problems: Array<string> }> => {
+	const { keys, report, host, registry } = options;
+	const repos_command = to_repos_command(registry);
+	const by_key = new Map(report.entries.map((e) => [e.key, e] as const));
+
+	const problems: Array<string> = [];
+	const resolved: Array<LocalRepoPath> = [];
+	for (const key of keys) {
+		const entry = by_key.get(key);
+		if (!entry) {
+			// `repos` also takes a dir name or path as a target, reporting the entry by its key
+			const by_dir = report.entries.find((e) => e.dir === key);
+			problems.push(
+				by_dir
+					? `\`${key}\` is the dir of \`${by_dir.key}\`, not a registry key — list \`${by_dir.key}\``
+					: `\`${key}\` isn't in the \`repos status\` report — is it a registry key?`
+			);
+			continue;
+		}
+		const repo_dir = join(report.workspace, entry.dir);
+		if (entry.kind === 'reference') {
+			problems.push(`\`${key}\` is a third-party reference, not an owned repo`);
+		} else if (entry.presence.kind === 'missing') {
+			problems.push(
+				`\`${key}\` is missing at ${repo_dir} — \`${repos_command} sync ${key}\` clones it`
+			);
+		} else if (entry.presence.kind === 'not_a_repo') {
+			problems.push(`\`${key}\`: ${repo_dir} isn't a git repo`);
+		} else if (entry.probe_error !== null) {
+			problems.push(`\`${key}\`: probing ${repo_dir} failed: ${entry.probe_error.message}`);
+		} else {
+			resolved.push({ repo_name: key, repo_dir, repo_url: entry.url, entry });
+		}
+	}
+
+	if (host) {
+		const configured = keys.map((k) => by_key.get(k)).filter((e) => e !== undefined);
+		for (const leaked of gitops_config_leaked_private_repos(configured, host.private)) {
+			problems.push(
+				`\`${leaked.key}\` is private, and ${host.name} is a public package whose generated repos.json would publish its metadata`
+			);
+		}
+	}
+
+	if (problems.length) {
+		return {
+			ok: false,
+			message: `${problems.length === 1 ? 'a configured repo' : 'configured repos'} can't be loaded:\n  ${problems.join('\n  ')}`,
+			problems
+		};
+	}
+	return { ok: true, value: resolved };
+};
 
 /**
- * Loads repo data, optionally syncing the working tree first.
+ * Loads a resolved repo as its working tree sits (the tasks read where each
+ * repo sits from `repos status`, and `repos sync` moves them). Moves no ref;
+ * gro caches the library at `.gro/library.json` in the repo, at a clean commit.
  *
- * When `sync` is `false` (the default for read-only diagnostics like
- * `gitops_analyze`/`gitops_plan`), the repo is loaded exactly as it sits on
- * disk — no branch switch, pull, install, or clean-workspace check. This makes
- * those commands safe to run on an active workspace with uncommitted changes or
- * feature branches checked out.
+ * 1. Loads `library_json` via `library_load_from_repo` (svelte-docinfo analysis)
+ * 2. Creates `Library` and extracts dependency maps
  *
- * When `sync` is `true` (used by `gitops_sync`), the working tree is brought in
- * line with the configured branch first:
- * 1. Records current commit hash (for detecting changes)
- * 2. Switches to target branch if needed (requires clean workspace unless `allow_dirty`)
- * 3. Pulls latest changes from remote (skipped for local-only repos)
- * 4. Validates workspace is clean after pull (skipped if `allow_dirty`)
- * 5. Auto-installs dependencies if `package.json` changed
+ * A repo with no `package.json` but a Rust `Cargo.toml` loads as a
+ * dashboard-only `cargo` repo instead.
  *
- * Either way it then:
- * 6. Loads `library_json` via `library_load_from_repo` (svelte-docinfo analysis)
- * 7. Creates `Library` and extracts dependency maps
- *
- * @param sync - sync the working tree to the configured branch before loading (default `true`)
- * @param allow_dirty - when syncing, tolerate uncommitted changes instead of throwing (default `false`)
- * @throws {TaskError} if syncing fails (dirty workspace, branch switch, install) or analysis fails
+ * @throws {TaskError} if the analysis fails
  */
 export const local_repo_load = async ({
 	local_repo_path,
-	log: _log,
-	git_ops = default_git_operations,
-	npm_ops = default_npm_operations,
-	sync = true,
-	allow_dirty = false
+	log
 }: {
 	local_repo_path: LocalRepoPath;
 	log?: Logger;
-	git_ops?: GitOperations;
-	npm_ops?: NpmOperations;
-	sync?: boolean;
-	allow_dirty?: boolean;
 }): Promise<LocalRepo> => {
-	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 });
-		if (!commit_before_result.ok) {
-			throw new TaskError(
-				`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 });
-		if (!branch_result.ok) {
-			throw new TaskError(`Failed to get current branch in ${repo_dir}: ${branch_result.message}`);
-		}
-
-		const switched_branches = branch_result.value !== repo_config.branch;
-		if (switched_branches) {
-			// 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 });
-				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`
-					);
-				}
-			}
-
-			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}`
-				);
-			}
-		}
-
-		// 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 });
-		if (!origin_result.ok) {
-			throw new TaskError(`Failed to check for remote in ${repo_dir}: ${origin_result.message}`);
-		}
-
-		if (origin_result.value) {
-			// 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 });
-			if (!pull_result.ok) {
-				throw new TaskError(`Failed to pull in ${repo_dir}: ${pull_result.message}`);
-			}
-		}
-
-		// 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 });
-			if (!clean_after_result.ok) {
-				throw new TaskError(
-					`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}"`
-				);
-			}
-		}
-
-		// Record commit hash after pull
-		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}`
-			);
-		}
-		const commit_after = commit_after_result.value;
-
-		// Track if we got new commits
-		const got_new_commits = commit_before !== commit_after;
-
-		// Only install if package.json changed
-		if (got_new_commits) {
-			const changed_result = await git_ops.has_file_changed({
-				from_commit: commit_before,
-				to_commit: commit_after,
-				file_path: 'package.json',
-				cwd: repo_dir
-			});
-
-			if (!changed_result.ok) {
-				throw new TaskError(
-					`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 });
-				if (!install_result.ok) {
-					throw new TaskError(
-						`Failed to install dependencies in ${repo_dir}: ${install_result.message}${install_result.stderr ? `\n${install_result.stderr}` : ''}`
-					);
-				}
-			}
-		}
-	}
+	const { entry, repo_dir, repo_name } = local_repo_path;
 
 	// A repo with no `package.json` but a Rust `Cargo.toml` isn't an npm package and can't be
 	// analyzed as a library. Load it as a dashboard-only `cargo` repo (CI, PRs, identity) that
@@ -232,14 +163,10 @@ export const local_repo_load = async ({
 	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 }));
 	} catch (err) {
-		const message = to_error_message(err);
-		_log?.warn(
-			`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}: ${to_error_message(err)}`
 		);
 	}
 	const library = new Library(library_json);
@@ -249,8 +176,7 @@ export const local_repo_load = async ({
 		library,
 		package_json,
 		repo_dir,
-		repo_git_ssh_url,
-		repo_config
+		entry
 	};
 
 	// Extract dependencies from the full package_json
@@ -269,8 +195,8 @@ export const local_repo_load = async ({
 
 /**
  * Whether a repo is an npm package and so participates in publishing and
- * dependency analysis. Non-npm repos (e.g. Rust `cargo` repos) are still synced
- * and rendered on the dashboard, but excluded from the changeset cascade.
+ * dependency analysis. Non-npm repos (e.g. Rust `cargo` repos) are still
+ * rendered on the dashboard, but excluded from the changeset cascade.
  */
 export const repo_is_npm = (repo: LocalRepo): boolean => repo.kind === 'npm';
 
@@ -278,7 +204,7 @@ export const repo_is_npm = (repo: LocalRepo): boolean => repo.kind === 'npm';
  * Loads a non-npm Rust repo as a dashboard-only `LocalRepo`. It has no
  * `package.json`, so there's no `svelte-docinfo` analysis and no npm dependency
  * graph — a lightweight `Library` is synthesized from the repo's `Cargo.toml`
- * (best-effort name/version/description) and its configured repo URL, which is
+ * (best-effort name/version/description) and its registry URL, which is
  * what the dashboard renders (CI status, PRs, identity). Marked `private` so it
  * never reads as an npm publish target, and tagged `cargo` so the publishing and
  * analysis paths skip it (see `repo_is_npm`).
@@ -288,12 +214,12 @@ const local_repo_load_cargo = async ({
 }: {
 	local_repo_path: LocalRepoPath;
 }): Promise<LocalRepo> => {
-	const { repo_config, repo_dir, repo_name, repo_url, repo_git_ssh_url } = local_repo_path;
+	const { entry, repo_dir, repo_name, repo_url } = local_repo_path;
 
 	const cargo = await cargo_toml_load(repo_dir);
 
-	// A Cargo workspace root has no `name`, so fall back to the repo name parsed from
-	// the URL; the config's `repo_url` is the authoritative `repository`.
+	// A Cargo workspace root has no `name` or `repository`, so fall back to the
+	// registry key and URL.
 	const package_json: PackageJson = {
 		name: cargo?.name ?? repo_name,
 		version: cargo?.version ?? '0.0.0',
@@ -309,87 +235,26 @@ const local_repo_load_cargo = async ({
 		library,
 		package_json,
 		repo_dir,
-		repo_git_ssh_url,
-		repo_config
+		entry
 	};
 };
 
-export const local_repos_ensure = async ({
-	resolved_config,
-	repos_dir,
-	gitops_config,
-	download,
-	log,
-	npm_ops = default_npm_operations
-}: {
-	resolved_config: ResolvedGitopsConfig;
-	repos_dir: string;
-	gitops_config: GitopsConfig;
-	download: boolean;
-	log?: Logger;
-	npm_ops?: NpmOperations;
-}): Promise<Array<LocalRepoPath>> => {
-	let local_repo_paths: Array<LocalRepoPath> | null = null;
-
-	if (!resolved_config.local_repos_missing) {
-		local_repo_paths = resolved_config.local_repo_paths;
-	} else {
-		if (download) {
-			const downloaded = await download_repos({
-				repos_dir,
-				local_repos_missing: resolved_config.local_repos_missing,
-				log,
-				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)
-				);
-		} 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)
-			);
-			throw new TaskError('Failed to resolve local configs');
-		}
-	}
-
-	if (!local_repo_paths) {
-		throw new TaskError('No repos are configured in `gitops_config.ts`');
-	}
-
-	return local_repo_paths;
-};
-
 export const local_repos_load = async ({
 	local_repo_paths,
 	log,
-	git_ops = default_git_operations,
-	npm_ops = default_npm_operations,
 	parallel = true,
-	concurrency = GITOPS_CONCURRENCY_DEFAULT,
-	sync = true,
-	allow_dirty = false
+	concurrency = GITOPS_CONCURRENCY_DEFAULT
 }: {
 	local_repo_paths: Array<LocalRepoPath>;
 	log?: Logger;
-	git_ops?: GitOperations;
-	npm_ops?: NpmOperations;
 	parallel?: boolean;
 	concurrency?: number;
-	sync?: boolean;
-	allow_dirty?: boolean;
 }): Promise<Array<LocalRepo>> => {
 	if (!parallel) {
-		// Sequential loading (original behavior)
+		// sequential loading
 		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 })
-			);
+			loaded.push(await local_repo_load({ local_repo_path, log }));
 		}
 		return loaded;
 	}
@@ -399,7 +264,7 @@ 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 });
 		}
 	);
 
@@ -428,75 +293,3 @@ export const local_repos_load = async ({
 
 	return loaded;
 };
-
-export const local_repo_locate = ({
-	repo_config,
-	repos_dir
-}: {
-	repo_config: GitopsRepoConfig;
-	repos_dir: string;
-}): LocalRepoPath | LocalRepoMissing => {
-	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);
-
-	const repo_git_ssh_url = to_repo_git_ssh_url(repo_url);
-
-	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_path',
-		repo_name,
-		repo_dir,
-		repo_url,
-		repo_git_ssh_url,
-		repo_config
-	};
-};
-
-const to_repo_git_ssh_url = (repo_url: string): string => {
-	const url = new URL(repo_url);
-	return `git@${url.hostname}:${url.pathname.substring(1)}`;
-};
-
-const download_repos = async ({
-	repos_dir,
-	local_repos_missing,
-	log,
-	npm_ops = default_npm_operations
-}: {
-	repos_dir: string;
-	local_repos_missing: Array<LocalRepoMissing>;
-	log?: Logger;
-	npm_ops?: NpmOperations;
-}): Promise<Array<LocalRepoPath>> => {
-	const resolved: Array<LocalRepoPath> = [];
-	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 });
-		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() : ''}`
-			);
-		}
-		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`
-			);
-		}
-		// 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 });
-		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}` : ''}`
-			);
-		}
-		resolved.push(local_repo);
-	}
-	return resolved;
-};

package/src/lib/log_helpers.ts

@@ -1,15 +1,13 @@
 import type { Logger } from '@fuzdev/fuz_util/log.ts';
 import { styleText as st } from 'node:util';
 
-import type { DependencyGraphBuilder } from './dependency_graph.ts';
+import type { DependencyAnalysis } from './dependency_graph.ts';
 
 /**
  * Formats wildcard dependencies as styled strings.
  * Returns array of lines for inclusion in output.
  */
-export const format_wildcard_dependencies = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>
-): Array<string> => {
+export const format_wildcard_dependencies = (analysis: DependencyAnalysis): Array<string> => {
 	if (analysis.wildcard_deps.length === 0) return [];
 
 	const lines: Array<string> = [];
@@ -27,9 +25,7 @@ export const format_wildcard_dependencies = (
  * Formats dev circular dependencies as styled strings.
  * Returns array of lines for inclusion in output.
  */
-export const format_dev_cycles = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>
-): Array<string> => {
+export const format_dev_cycles = (analysis: DependencyAnalysis): Array<string> => {
 	if (analysis.dev_cycles.length === 0) return [];
 
 	const lines: Array<string> = [];
@@ -50,9 +46,7 @@ export const format_dev_cycles = (
  * Formats production/peer circular dependencies as styled strings.
  * Returns array of lines for inclusion in output.
  */
-export const format_production_cycles = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>
-): Array<string> => {
+export const format_production_cycles = (analysis: DependencyAnalysis): Array<string> => {
 	if (analysis.production_cycles.length === 0) return [];
 
 	const lines: Array<string> = [];
@@ -74,7 +68,7 @@ export const format_production_cycles = (
  * Wildcard dependencies require attention and should be reviewed.
  */
 export const log_wildcard_dependencies = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
+	analysis: DependencyAnalysis,
 	log: Logger,
 	indent = ''
 ): void => {
@@ -88,11 +82,7 @@ export const log_wildcard_dependencies = (
  * Logs dev circular dependencies as info.
  * Dev cycles are normal and non-blocking, so they're informational, not warnings.
  */
-export const log_dev_cycles = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
-	log: Logger,
-	indent = ''
-): void => {
+export const log_dev_cycles = (analysis: DependencyAnalysis, log: Logger, indent = ''): void => {
 	const lines = format_dev_cycles(analysis);
 	for (const line of lines) {
 		log.info(indent + line);
@@ -104,7 +94,7 @@ export const log_dev_cycles = (
  * Production cycles block publishing and must be resolved.
  */
 export const log_production_cycles = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
+	analysis: DependencyAnalysis,
 	log: Logger,
 	indent = ''
 ): void => {
@@ -119,7 +109,7 @@ export const log_production_cycles = (
  * Convenience function that calls all three logging functions in order.
  */
 export const log_dependency_analysis = (
-	analysis: ReturnType<DependencyGraphBuilder['analyze']>,
+	analysis: DependencyAnalysis,
 	log: Logger,
 	indent = ''
 ): void => {