Builds the dependency graph and runs cycle/wildcard analysis, tolerating cycles (reports rather than throws). The shared core of gitops_analyze and gitops_validate, which format the result themselves — so this stays silent (no log) to avoid emitting a redundant "Analyzing dependencies" line.

Build operations for validating packages compile before publishing.

A semver bump kind: major, minor, or patch.

Calculates all dependency updates between packages based on predicted versions.

Iterates through all repos, checking prod, peer, and dev dependencies to find which packages will need dependency version bumps after publishing.

Also tracks "breaking cascades" - when a breaking change propagates to dependents.

Collects events in memory. Used to build the run report and in tests.

A capture_handler also exposes the events it has collected.

Best-effort read of a repo's root Cargo.toml for the identity fields the gitops dashboard renders. Returns null when there's no Cargo.toml.

Extracts name/version/description/repository from the [package] and [workspace.package] tables of a Cargo.toml.

Deliberately not a full TOML parser: it scans for simple key = "value" string entries in those two tables, which covers both a single-crate manifest and a workspace root. Inline-table values like version = { workspace = true } (and the equivalent version.workspace = true) are ignored — a member crate inheriting from the workspace has no literal here, and gitops only ever reads a repo's root manifest, where these are concrete. The first non-empty value for a key wins, so a top-level [package] takes precedence over [workspace.package] when both appear.

The handful of identity fields gitops reads from a Rust repo's Cargo.toml to render it on the dashboard. Everything is optional — a workspace root has no name, and any field may be absent or inherited.

Changeset operations for reading and predicting versions from .changeset/*.md files.

How a repo's declared ci diverges from its workflow files on disk.

Collect all files from walk_repo_files into an array. Convenience function for when you need all paths upfront.

Compares bump types. Returns positive if a > b, negative if a < b, 0 if equal.

Creates a changeset file for dependency updates. Returns the path to the created changeset file.

Creates file-system backed cache for fuz_util's fetch.js API responses.

Cache invalidation strategy: If cache file can't be read or parsed, entire cache is cleared (delete file) and starts fresh. This handles format changes.

Uses structuredClone to track changes - only writes to disk if data modified. Formatted with Prettier before writing for version control friendliness.

Decides whether a publish run must block, prompt for confirmation, or proceed without prompting, from the pre-execution inputs.

• blocked: a real publish whose plan has errors — fail loud before prompting. The executor enforces this too, so --no-plan can't bypass the gate; this branch only avoids prompting for (and printing the "this will publish" banner of) a plan that can't run.
• confirm: a real publish that shows its plan — the user must confirm interactively.
• proceed: a dry run, or a --no-plan real publish — no prompt.

Default directories to exclude from file walking

Default binary/non-text extensions to exclude from content processing

Combined default operations for all gitops functionality.

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/).

Cycles, wildcard deps, and missing peers produced by DependencyGraphBuilder.analyze.

Builder for creating and analyzing dependency graphs.

Derives the ordered side-effects a wetrun would perform from a frozen plan.

Reads only publishing_order, version_changes, and dependency_updates — the same data execute_publishing_plan consumes, in the same order — so the preview reflects the real pass. A dependency is only propagated to its dependents if it actually publishes this run.

Determines the bump type for a package from its changesets.

When multiple changesets exist for the same package, returns the highest bump type (major > minor > patch) to ensure the most significant change is reflected in the version bump.

Executes a frozen publishing plan in a single linear pass — the "dumb executor" half of the zap model. The plan is the single source of truth; this re-derives nothing.

Fails loud when the plan couldn't be fully computed (plan.errors): a wetrun aborts before any side effect, a dry run still reports the partial cascade but returns ok: false. This is the single error gate — --no-plan can't bypass it.

Fetches GitHub metadata (CI status, PRs) for all repos.

Fetches sequentially with delay between requests to respect GitHub API rate limits. Uses await_in_loop intentionally to avoid parallel requests overwhelming the API.

Error handling: Logs fetch failures but continues processing remaining repos. Repos with failed fetches will have null for check_runs or pull_requests.

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

Formats dev circular dependencies as styled strings. Returns array of lines for inclusion in output.

Formats production/peer circular dependencies as styled strings. Returns array of lines for inclusion in output.

Formats steps as human-readable lines (one per step) for stdout and markdown output. Returns a single placeholder line when there are no side effects.

Formats wildcard dependencies as styled strings. Returns array of lines for inclusion in output.

File system operations for reading and writing files.

Errors are typed via FsError (`not_found | permission_denied | already_exists | io_error) so callers can branch on kind` instead of regex-matching message. See @fuzdev/fuz_util/fs.ts.

Generates markdown changeset content for dependency updates.

Creates properly formatted changeset with YAML frontmatter, summary, and categorized list of breaking vs regular updates. Output format matches changesets CLI for consistency.

Generates a publishing plan showing what would happen during publishing. Shows version changes, dependency updates, and breaking change cascades. Uses fixed-point iteration to resolve transitive cascades.

Central initialization function for all gitops tasks.

Initialization sequence:

1. Loads and normalizes config from gitops.config.ts
2. Resolves local repo paths (creates missing with --download)
3. If sync, switches branches and pulls latest changes (in parallel by default)
4. If sync, auto-installs deps if package.json changed during pull

With sync: false (the default for read-only diagnostics), steps 3-4 are skipped and repos are loaded exactly as checked out — no branch switch, pull, install, or clean-workspace check.

Priority for path resolution:

• dir argument (explicit override)
• Config repos_dir setting
• DEFAULT_REPOS_DIR constant

Fetches package metadata from NPM registry.

Returns name and latest version. Returns null if package doesn't exist or registry is unreachable.

Get repo paths from gitops config without full git sync. Lighter weight than get_gitops_ready() - just resolves paths.

Determines the required bump type for a package based on its dependency updates.

Returns null if no prod/peer dependency updates, otherwise returns the minimum required bump type (major for breaking deps, patch otherwise).

Respects pre-1.0 semver conventions (minor for breaking in 0.x).

Determines version prefix to use when updating dependencies.

Strategy:

• Wildcard (*): Use caret (^) as default
• Has existing prefix: Preserve it (^, ~, >=, <=, etc)
• No prefix: Use default_strategy

This preserves user intent while handling wildcard replacements sensibly.

Gets the version prefix (^, ~, >=, <=, or empty string).

Adds files to git staging area and throws if anything goes wrong.

Adds files and commits in one operation and throws if anything goes wrong.

Wrapper for gro's git_check_clean_workspace that returns a boolean.

Commits staged changes with a message and throws if anything goes wrong.

Wrapper for gro's git_current_branch_name that throws if null.

Wrapper for gro's git_current_commit_hash that throws if null.

Returns true if the working tree has any changes — staged, unstaged, or untracked (git status --porcelain). Broader than git_list_uncommitted_files, which reports only tracked working-tree changes relative to HEAD.

Lists uncommitted files in the working tree (git diff --name-only HEAD).

Pushes a tag to origin and throws if anything goes wrong.

Stashes current changes and throws if anything goes wrong.

Applies stashed changes and throws if anything goes wrong.

Switches to a branch with safety checks and throws if workspace is not clean.

Creates a git tag and throws if anything goes wrong.

Minimal interface for GitHub API calls - works with both Pkg and Repo.

Git operations for branch management, commits, tags, and workspace state. All operations return Result instead of throwing errors.

Default number of repos to process concurrently during parallel operations.

Default path to the gitops configuration file.

Maximum number of iterations for fixed-point iteration during publishing. Used in both plan generation and actual publishing to resolve transitive dependency cascades.

In practice, most repos converge in 2-3 iterations. Deep dependency chains may require more iterations.

Default timeout in milliseconds for waiting on NPM package propagation (10 minutes). NPM's CDN uses eventual consistency, so published packages may not be immediately available.

Combined operations interface grouping all gitops functionality. This is the main interface injected into publishing and validation workflows.

Visibility of a repo on its host, mirroring the host's own model (e.g. GitHub's visibility field). Named to avoid confusion with the npm package.json private flag, which is a separate publishing concern.

Groups dependency updates by dependent package — `dependent → (dependency → new version), the shape update_package_json consumes. Restricted by predicate` (e.g. prod/peer for a given package, or all dev deps) and to dependencies that actually published this run, so a failed/aborted publish never propagates to its dependents.