@fuzdev/fuz_gitops 0.78.1 → 0.79.0

package/dist/repos_status_load.js

@@ -0,0 +1,131 @@
+/**
+ * Reads fleet git state from the Rust `repos` binary: runs
+ * `repos status <keys…> --json` through the injected `ReposOperations` and
+ * parses what it printed with the `repos_status.ts` mirror.
+ *
+ * Parsing is pure (`parse_repos_status_output`): the format version is read
+ * first, so a binary and npm package out of step fail with both versions and
+ * the install command rather than a schema error; then the document is parsed
+ * strictly as a report or, when it carries `error`, as an error document,
+ * whose kind maps to a message saying what to change.
+ *
+ * @module
+ */
+import { z } from 'zod';
+import { REPOS_STATUS_FORMAT_VERSION, ReposStatusErrorReport, ReposStatusReport } from './repos_status.js';
+/**
+ * How to install the `repos` binary, run in a `fuz_repos` checkout. The npm
+ * package doesn't carry the binary, so the two are installed separately.
+ */
+export const REPOS_INSTALL_COMMAND = 'cargo install --path crates/fuz_repos --locked';
+/**
+ * The `repos` invocation a suggested fix names: `repos`, or `repos --registry
+ * <path>` when the run passed one, the path POSIX-shell-quoted when it needs it.
+ *
+ * @param registry - the run's `--registry`, if any
+ * @returns the command prefix, ready for a subcommand
+ */
+export const to_repos_command = (registry) => registry === undefined ? 'repos' : `repos --registry ${shell_quote(registry)}`;
+const shell_quote = (arg) => /^[\w@%+=:,./-]+$/.test(arg) ? arg : `'${arg.replaceAll("'", `'\\''`)}'`;
+/**
+ * Parses what `repos status --json` printed into its report, or a message
+ * saying what went wrong and what to change.
+ *
+ * @param output - the command's stdout, stderr, and exit code
+ * @returns the report, or a message naming the error document's kind and hint, a format version mismatch, or output that isn't a status document; an error document rides along as `error`
+ */
+export const parse_repos_status_output = (output) => {
+    const { stdout, stderr, exit_code } = output;
+    let json;
+    try {
+        json = JSON.parse(stdout);
+    }
+    catch {
+        // exit 1 is a fatal I/O error, which may print no JSON
+        const detail = stderr.trim() || stdout.trim() || 'no output';
+        return {
+            ok: false,
+            message: `\`repos status --json\` exited ${exit_code} without a JSON document: ${detail}`
+        };
+    }
+    if (typeof json !== 'object' || json === null || Array.isArray(json)) {
+        return { ok: false, message: '`repos status --json` printed JSON that is not a document' };
+    }
+    const version = 'version' in json ? json.version : undefined;
+    if (version !== REPOS_STATUS_FORMAT_VERSION) {
+        const fix = typeof version === 'number' && version > REPOS_STATUS_FORMAT_VERSION
+            ? "upgrade @fuzdev/fuz_gitops to match the binary, or install the binary from a fuz_repos checkout at this package's version"
+            : "install the binary from a fuz_repos checkout at this package's version";
+        return {
+            ok: false,
+            message: `the \`repos\` binary prints status format ${JSON.stringify(version ?? null)}, ` +
+                `but this @fuzdev/fuz_gitops parses format ${REPOS_STATUS_FORMAT_VERSION}: ` +
+                `${fix} (\`${REPOS_INSTALL_COMMAND}\`) — the npm package and the binary are installed separately`
+        };
+    }
+    if ('error' in json) {
+        const parsed = ReposStatusErrorReport.safeParse(json);
+        if (!parsed.success) {
+            return {
+                ok: false,
+                message: `\`repos status --json\` printed an error document this package can't parse:\n${z.prettifyError(parsed.error)}`
+            };
+        }
+        return {
+            ok: false,
+            message: format_repos_status_error(parsed.data.error),
+            error: parsed.data.error
+        };
+    }
+    const parsed = ReposStatusReport.safeParse(json);
+    if (!parsed.success) {
+        return {
+            ok: false,
+            message: `\`repos status --json\` printed a report this package can't parse:\n${z.prettifyError(parsed.error)}`
+        };
+    }
+    return { ok: true, report: parsed.data };
+};
+const format_repos_status_error = (error) => {
+    switch (error.kind) {
+        case 'unknown_entry': {
+            const suggestions = error.suggestions.length
+                ? ` — did you mean ${error.suggestions.map((s) => `\`${s}\``).join(', ')}?`
+                : '';
+            return `the gitops config lists \`${error.name}\`, which the registry (repos.toml) doesn't name${suggestions}`;
+        }
+        case 'registry_not_found':
+            return (`${error.message}: the gitops tasks read repo state from a repos.toml registry — ` +
+                `run inside its workspace, or pass \`--registry <path>\``);
+        default: {
+            const hint = error.hint ? `\n  hint: ${error.hint}` : '';
+            return `\`repos status\` failed (${error.kind}): ${error.message}${hint}`;
+        }
+    }
+};
+/**
+ * Runs `repos status <keys…> --json` and parses its report.
+ *
+ * @param options.keys - the registry keys to report on; must not be empty, since no targets means every entry
+ * @param options.registry - a `repos.toml` to use instead of the one found walking up from the cwd
+ * @param options.fetch - fetch each entry from origin first (`--fetch`), which writes remote-tracking refs and nothing else
+ * @param options.repos_ops - the `repos` runner
+ * @returns the report, or a message saying what went wrong and what to change
+ */
+export const load_repos_status = async (options) => {
+    const { keys, registry, fetch, repos_ops } = options;
+    if (keys.length === 0) {
+        // `repos status` with no targets reports every entry
+        return { ok: false, message: 'no registry keys to report on' };
+    }
+    const ran = await repos_ops.status(fetch ? { keys, registry, fetch } : { keys, registry });
+    if (!ran.ok) {
+        return {
+            ok: false,
+            message: ran.kind === 'not_found'
+                ? `the \`repos\` binary was not found on PATH: install it from a fuz_repos checkout with \`${REPOS_INSTALL_COMMAND}\` — the npm package doesn't carry it`
+                : `\`repos status\` didn't run: ${ran.message}`
+        };
+    }
+    return parse_repos_status_output(ran.output);
+};

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@fuzdev/fuz_gitops",
-  "version": "0.78.1",
+  "version": "0.79.0",
   "description": "a tool for managing many repos",
   "glyph": "🪄",
   "logo": "logo.svg",
   "logo_alt": "a friendly blue spider facing you",
   "license": "MIT",
   "homepage": "https://gitops.fuz.dev/",
-  "repository": "https://github.com/fuzdev/fuz_gitops",
+  "repository": "https://github.com/fuzdev/fuz_repos",
   "author": {
     "name": "Ryan Atkinson",
     "email": "mail@ryanatkn.com",
     "url": "https://www.ryanatkn.com/"
   },
-  "bugs": "https://github.com/fuzdev/fuz_gitops/issues",
+  "bugs": "https://github.com/fuzdev/fuz_repos/issues",
   "funding": "https://www.ryanatkn.com/funding",
   "scripts": {
     "start": "gro dev",
@@ -39,12 +39,12 @@
   },
   "devDependencies": {
     "@changesets/changelog-git": "^0.2.1",
-    "@fuzdev/blake3_wasm": "^0.1.1",
+    "@fuzdev/blake3-wasm": "^0.2.0",
     "@fuzdev/fuz_code": "^0.48.0",
-    "@fuzdev/fuz_css": "^0.63.3",
+    "@fuzdev/fuz_css": "^0.64.0",
     "@fuzdev/fuz_ui": "^0.208.0",
-    "@fuzdev/fuz_util": "^0.68.0",
-    "@fuzdev/gro": "^0.210.1",
+    "@fuzdev/fuz_util": "^0.69.0",
+    "@fuzdev/gro": "^0.212.0",
     "@fuzdev/mdz": "^0.3.0",
     "@ryanatkn/eslint-config": "^0.12.2",
     "@sveltejs/acorn-typescript": "^1.0.9",
@@ -59,8 +59,6 @@
     "eslint-plugin-svelte": "^3.13.1",
     "esm-env": "^1.2.2",
     "magic-string": "^0.30.21",
-    "prettier": "^3.9.6",
-    "prettier-plugin-svelte": "^4.1.1",
     "svelte": "^5.56.2",
     "svelte-check": "^4.6.0",
     "svelte-docinfo": "^0.7.0",
@@ -73,24 +71,6 @@
     "zimmerframe": "^1.1.4",
     "zod": "^4.3.6"
   },
-  "prettier": {
-    "plugins": [
-      "prettier-plugin-svelte"
-    ],
-    "useTabs": true,
-    "printWidth": 100,
-    "singleQuote": true,
-    "bracketSpacing": true,
-    "trailingComma": "none",
-    "overrides": [
-      {
-        "files": "package.json",
-        "options": {
-          "useTabs": false
-        }
-      }
-    ]
-  },
   "sideEffects": [
     "**/*.css"
   ],

package/src/lib/ci_reconcile.ts

@@ -2,14 +2,12 @@
  * Reconciles each repo's declared `ci` flag against whether it actually has
  * GitHub Actions workflow files on disk.
  *
- * The gitops config derives `ci` from visibility (on for public repos, off for
- * private) with per-repo overrides; this check catches drift between that
- * declaration and reality —
+ * The registry (`repos.toml`) derives `ci` from visibility (on for public repos,
+ * off for private) with per-repo overrides; this check catches drift between
+ * that declaration and reality —
  * a repo that claims CI but ships no workflow, or one that disclaims CI yet
- * still carries one. Repos that aren't checked out locally can't be judged, so
- * the caller marks them uncheckable and they're skipped. Archived repos are
- * frozen on their host, so their CI state is intentionally left alone and they're
- * skipped too.
+ * still carries one. Archived repos are frozen on their host, so their CI state
+ * is intentionally left alone and they're skipped.
  *
  * @module
  */
@@ -34,12 +32,10 @@ export interface CiDrift {
 
 export interface CiReconcileInput {
 	repo_url: string;
-	/** The declared/derived `ci` value from the gitops config. */
+	/** The declared/derived `ci` value from the registry. */
 	ci: boolean;
 	/** Whether the repo has at least one workflow file on disk. */
 	has_workflows: boolean;
-	/** Whether the repo is checked out locally; uncheckable repos are skipped. */
-	checkable: boolean;
 	/** Whether the repo is archived (frozen) on its host; archived repos are skipped. */
 	archived: boolean;
 }
@@ -51,7 +47,7 @@ export interface CiReconcileInput {
 export const reconcile_ci = (repos: Array<CiReconcileInput>): Array<CiDrift> => {
 	const drift: Array<CiDrift> = [];
 	for (const repo of repos) {
-		if (!repo.checkable || repo.archived) continue;
+		if (repo.archived) continue;
 		const { repo_url, ci, has_workflows } = repo;
 		if (ci && !has_workflows) {
 			drift.push({ repo_url, ci, has_workflows, kind: 'missing_ci' });

package/src/lib/dependency_graph.ts

@@ -1,9 +1,10 @@
 /**
  * Dependency graph data structure and algorithms for multi-repo publishing.
  *
- * Provides `DependencyGraph` class with topological sort (via `@fuzdev/fuz_util/sort.ts`)
- * and cycle detection by dependency type.
- * For validation workflow and publishing order computation, see `graph_validation.ts`.
+ * Provides the `DependencyGraph` class, built from local repos, with topological sort
+ * (via `@fuzdev/fuz_util/sort.ts`), cycle detection by dependency type, and
+ * wildcard-range analysis.
+ * For the publishing order and the analysis workflow, see `graph_validation.ts`.
  *
  * @module
  */
@@ -24,7 +25,6 @@ export type DependencyType = (typeof DEPENDENCY_TYPE)[keyof typeof DEPENDENCY_TY
 export interface DependencySpec {
 	type: DependencyType;
 	version: string;
-	resolved?: string;
 }
 
 export interface DependencyGraphJson {
@@ -33,7 +33,6 @@ export interface DependencyGraphJson {
 		version: string;
 		dependencies: Array<{ name: string; spec: DependencySpec }>;
 		dependents: Array<string>;
-		publishable: boolean;
 	}>;
 	edges: Array<{ from: string; to: string }>;
 }
@@ -41,41 +40,43 @@ export interface DependencyGraphJson {
 export interface DependencyNode {
 	name: string;
 	version: string;
-	repo?: LocalRepo;
 	dependencies: Map<string, DependencySpec>;
 	dependents: Set<string>;
-	publishable: boolean;
 }
 
-export class DependencyGraph {
-	nodes: Map<string, DependencyNode>;
-	edges: Map<string, Set<string>>; // pkg -> dependents
+/** Cycles and wildcard dependencies found by `DependencyGraph.analyze`. */
+export interface DependencyAnalysis {
+	production_cycles: Array<Array<string>>;
+	dev_cycles: Array<Array<string>>;
+	wildcard_deps: Array<{ pkg: string; dep: string; version: string }>;
+}
 
-	constructor() {
-		this.nodes = new Map();
-		this.edges = new Map();
-	}
+export class DependencyGraph {
+	nodes: Map<string, DependencyNode> = new Map();
+	edges: Map<string, Set<string>> = new Map(); // pkg -> dependents
 
-	public init_from_repos(repos: Array<LocalRepo>): void {
-		// First pass: create nodes
+	/**
+	 * Builds the graph from local repos.
+	 *
+	 * Two passes: first creates nodes, then builds edges (dependents).
+	 * Prioritizes prod/peer deps over dev deps when the same package appears in
+	 * multiple dependency types (the stronger constraint wins).
+	 */
+	constructor(repos: Array<LocalRepo>) {
+		// first pass: create nodes
 		for (const repo of repos) {
 			const { library, package_json } = repo;
 			const node: DependencyNode = {
 				name: library.name,
 				version: package_json.version || '0.0.0',
-				repo,
 				dependencies: new Map(),
-				dependents: new Set(),
-				publishable: !package_json.private
+				dependents: new Set()
 			};
 
-			// Extract dependencies
 			const deps = package_json.dependencies || (EMPTY_OBJECT as Record<string, string>);
 			const dev_deps = package_json.devDependencies || (EMPTY_OBJECT as Record<string, string>);
 			const peer_deps = package_json.peerDependencies || (EMPTY_OBJECT as Record<string, string>);
 
-			// Add dependencies, prioritizing prod/peer over dev
-			// (if a package appears in multiple dep types, use the stronger constraint)
 			for (const [name, version] of Object.entries(deps)) {
 				node.dependencies.set(name, { type: DEPENDENCY_TYPE.PROD, version });
 			}
@@ -83,7 +84,7 @@ export class DependencyGraph {
 				node.dependencies.set(name, { type: DEPENDENCY_TYPE.PEER, version });
 			}
 			for (const [name, version] of Object.entries(dev_deps)) {
-				// Only add dev deps if not already present as prod/peer
+				// only add dev deps if not already present as prod/peer
 				if (!node.dependencies.has(name)) {
 					node.dependencies.set(name, { type: DEPENDENCY_TYPE.DEV, version });
 				}
@@ -93,12 +94,11 @@ export class DependencyGraph {
 			this.edges.set(library.name, new Set());
 		}
 
-		// Second pass: build edges (dependents)
+		// second pass: build edges (dependents) for internal dependencies
 		for (const node of this.nodes.values()) {
 			for (const [dep_name] of node.dependencies) {
-				if (this.nodes.has(dep_name)) {
-					// Internal dependency
-					const dep_node = this.nodes.get(dep_name)!;
+				const dep_node = this.nodes.get(dep_name);
+				if (dep_node) {
 					dep_node.dependents.add(node.name);
 					this.edges.get(dep_name)!.add(node.name);
 				}
@@ -110,15 +110,6 @@ export class DependencyGraph {
 		return this.nodes.get(name);
 	}
 
-	get_dependents(name: string): Set<string> {
-		return this.edges.get(name) || new Set();
-	}
-
-	get_dependencies(name: string): Map<string, DependencySpec> {
-		const node = this.nodes.get(name);
-		return node ? node.dependencies : new Map();
-	}
-
 	/**
 	 * Computes topological sort order for dependency graph.
 	 *
@@ -167,6 +158,23 @@ export class DependencyGraph {
 		return { production_cycles, dev_cycles };
 	}
 
+	/**
+	 * Reports cycles by type and wildcard (`*`) dependency ranges.
+	 * Tolerates cycles: it reports them rather than throwing.
+	 */
+	analyze(): DependencyAnalysis {
+		const { production_cycles, dev_cycles } = this.detect_cycles_by_type();
+		const wildcard_deps: DependencyAnalysis['wildcard_deps'] = [];
+		for (const node of this.nodes.values()) {
+			for (const [dep_name, spec] of node.dependencies) {
+				if (spec.version === '*') {
+					wildcard_deps.push({ pkg: node.name, dep: dep_name, version: spec.version });
+				}
+			}
+		}
+		return { production_cycles, dev_cycles, wildcard_deps };
+	}
+
 	/** DFS cycle detection following only edges that match the filter. */
 	#find_cycles(include: (spec: DependencySpec) => boolean): Array<Array<string>> {
 		const cycles: Array<Array<string>> = [];
@@ -219,8 +227,7 @@ export class DependencyGraph {
 				name,
 				spec
 			})),
-			dependents: Array.from(node.dependents),
-			publishable: node.publishable
+			dependents: Array.from(node.dependents)
 		}));
 
 		const edges: Array<{ from: string; to: string }> = [];
@@ -233,62 +240,3 @@ export class DependencyGraph {
 		return { nodes, edges };
 	}
 }
-
-/**
- * Builder for creating and analyzing dependency graphs.
- */
-export class DependencyGraphBuilder {
-	/**
-	 * Constructs dependency graph from local repos.
-	 *
-	 * Two-pass algorithm: first creates nodes, then builds edges (dependents).
-	 * Prioritizes prod/peer deps over dev deps when same package appears in
-	 * multiple dependency types (stronger constraint wins).
-	 *
-	 * @returns fully initialized dependency graph with all nodes and edges
-	 */
-	build_from_repos(repos: Array<LocalRepo>): DependencyGraph {
-		const graph = new DependencyGraph();
-		graph.init_from_repos(repos);
-		return graph;
-	}
-
-	/**
-	 * Computes publishing order using topological sort with dev deps excluded.
-	 *
-	 * Excludes dev dependencies to break circular dev dependency cycles while
-	 * preserving production/peer dependency ordering. This allows patterns like
-	 * shared test utilities that depend on each other for development.
-	 *
-	 * @returns package names in safe publishing order (dependencies before dependents)
-	 * @throws {Error} if production/peer cycles detected (cannot be resolved by exclusion)
-	 */
-	compute_publishing_order(graph: DependencyGraph): Array<string> {
-		return graph.topological_sort(true); // Exclude dev dependencies
-	}
-
-	analyze(graph: DependencyGraph): {
-		production_cycles: Array<Array<string>>;
-		dev_cycles: Array<Array<string>>;
-		wildcard_deps: Array<{ pkg: string; dep: string; version: string }>;
-		missing_peers: Array<{ pkg: string; dep: string }>;
-	} {
-		const { production_cycles, dev_cycles } = graph.detect_cycles_by_type();
-		const wildcard_deps: Array<{ pkg: string; dep: string; version: string }> = [];
-		const missing_peers: Array<{ pkg: string; dep: string }> = [];
-
-		for (const node of graph.nodes.values()) {
-			for (const [dep_name, spec] of node.dependencies) {
-				if (spec.version === '*') {
-					wildcard_deps.push({ pkg: node.name, dep: dep_name, version: spec.version });
-				}
-				if (spec.type === DEPENDENCY_TYPE.PEER && !graph.nodes.has(dep_name)) {
-					// External peer dependency
-					missing_peers.push({ pkg: node.name, dep: dep_name });
-				}
-			}
-		}
-
-		return { production_cycles, dev_cycles, wildcard_deps, missing_peers };
-	}
-}

package/src/lib/dependency_updater.ts

@@ -30,7 +30,7 @@ export interface UpdatePackageJsonOptions {
  * 3. Creates auto-changeset if `published_versions` provided (for transitive updates)
  * 4. Commits both `package.json` and changeset with standard message
  *
- * Uses version strategy to determine prefix (exact, caret, tilde) while preserving
+ * Uses version strategy to determine prefix (exact, caret, tilde, gte) while preserving
  * existing prefixes when possible.
  *
  * @throws {Error} if file operations or git operations fail
@@ -111,6 +111,8 @@ export const update_package_json = async (
 		throw new Error(`Failed to write package.json: ${write_result.message}`);
 	}
 
+	const staged: Array<string> = [];
+
 	// Create changeset if we have published version info
 	if (published_versions && published_versions.size > 0) {
 		// Build dependency updates info for changeset
@@ -153,6 +155,7 @@ export const update_package_json = async (
 			if (!add_result.ok) {
 				throw new Error(`Failed to stage changeset: ${add_result.message}`);
 			}
+			staged.push(changeset_path);
 		}
 	}
 
@@ -161,9 +164,12 @@ export const update_package_json = async (
 	if (!add_pkg_result.ok) {
 		throw new Error(`Failed to stage package.json: ${add_pkg_result.message}`);
 	}
+	staged.push('package.json');
 
+	// commit only what this staged, so nothing else in the index rides along
 	const commit_result = await git_ops.commit({
 		message: `update dependencies after publishing`,
+		files: staged,
 		cwd: repo.repo_dir
 	});
 	if (!commit_result.ok) {

package/src/lib/fetch_repo_data.ts

@@ -2,45 +2,80 @@ import type { Logger } from '@fuzdev/fuz_util/log.ts';
 import { wait } from '@fuzdev/fuz_util/async.ts';
 import type { FetchValueCache } from '@fuzdev/fuz_util/fetch.ts';
 
-import { fetch_github_check_runs, fetch_github_pull_requests } from './github.ts';
+import {
+	fetch_github_check_runs,
+	fetch_github_pull_requests,
+	type GithubCheckRunsItem
+} from './github.ts';
 import type { RepoJson } from './repo.svelte.ts';
 import type { LocalRepo } from './local_repo.ts';
 
+/**
+ * Options for `fetch_repo_data`.
+ */
+export interface FetchRepoDataOptions {
+	/** The repos to fetch GitHub metadata for, in order. */
+	local_repos: Array<LocalRepo>;
+	/** GitHub API token, sent with each request. */
+	token?: string;
+	/** Response memoization, from `fuz_util`'s `fetch.ts`. */
+	cache?: FetchValueCache;
+	log?: Logger;
+	/** Milliseconds to wait before each API request. Defaults to `33`. */
+	delay?: number;
+	/** Sent as the `x-github-api-version` header when set. */
+	github_api_version?: string;
+	/** The `fetch` the API requests go through. Defaults to `globalThis.fetch`. */
+	fetch?: typeof globalThis.fetch;
+}
+
 /**
  * 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.
+ * Fetches sequentially with a delay before each request to respect GitHub API
+ * rate limits. Uses `await_in_loop` intentionally to avoid parallel requests
+ * overwhelming the API. CI status is read for the branch each repo's registry
+ * entry follows (`main` when it names none), and that branch is written to
+ * `RepoJson.branch`.
  *
- * Error handling: Logs fetch failures but continues processing remaining repos.
- * Repos with failed fetches will have `null` for `check_runs` or `pull_requests`.
+ * A repo whose registry entry declares no CI (`ci: false`) isn't asked for
+ * check runs, and one with none on its branch isn't a failure: both leave
+ * `check_runs` `null` without logging. A failed fetch is logged as an error
+ * and leaves `null` for that repo's `check_runs` or `pull_requests`, and the
+ * remaining repos still fetch — except a 401 response or a repo URL without a
+ * GitHub owner, which throw.
  *
- * @param delay - milliseconds between API requests (default: 33ms)
- * @param cache - optional cache from `fuz_util`'s `fetch.js` for response memoization
- * @returns array of `Repo` objects with GitHub metadata attached
+ * @param options - the repos, credentials, cache, and pacing
+ * @returns a `RepoJson` for each repo, in the order given
+ * @throws {Error} on a 401 response (check `SECRET_GITHUB_API_TOKEN`) or a
+ *   repo whose URL has no GitHub owner
  */
-export const fetch_repo_data = async (
-	resolved_repos: Array<LocalRepo>,
-	token?: string,
-	cache?: FetchValueCache,
-	log?: Logger,
-	delay = 33,
-	github_api_version?: string
-): Promise<Array<RepoJson>> => {
+export const fetch_repo_data = async (options: FetchRepoDataOptions): Promise<Array<RepoJson>> => {
+	const { local_repos, token, cache, log, delay = 33, github_api_version, fetch } = options;
 	const repos: Array<RepoJson> = [];
-	for (const { library, package_json, repo_config } of resolved_repos) {
+	for (const { library, package_json, entry } of local_repos) {
 		const repo_url = library.repo_url;
+		const branch = entry.branch ?? 'main';
 
-		// CI status
-		await wait(delay);
-		const check_runs = await fetch_github_check_runs(library, {
-			cache,
-			log,
-			token,
-			api_version: github_api_version,
-			ref: repo_config.branch
-		});
-		if (!check_runs) log?.error('failed to fetch CI status: ' + repo_url);
+		// CI status, for repos the registry says run CI
+		let check_runs: GithubCheckRunsItem | null = null;
+		if (entry.ci) {
+			await wait(delay);
+			const fetched = await fetch_github_check_runs(library, {
+				cache,
+				log,
+				token,
+				api_version: github_api_version,
+				ref: branch,
+				fetch
+			});
+			if (fetched.ok) {
+				check_runs = fetched.value;
+				if (!check_runs) log?.debug(`no check runs on \`${branch}\`: ${repo_url}`);
+			} else {
+				log?.error(`failed to fetch CI status (${fetched.status}): ${repo_url}`);
+			}
+		}
 
 		// pull requests
 		await wait(delay);
@@ -48,13 +83,15 @@ export const fetch_repo_data = async (
 			cache,
 			log,
 			token,
-			api_version: github_api_version
+			api_version: github_api_version,
+			fetch
 		});
-		if (!pull_requests) log?.error('failed to fetch issues: ' + repo_url);
+		if (!pull_requests) log?.error('failed to fetch pull requests: ' + repo_url);
 
 		repos.push({
 			library_json: library.library_json,
 			package_json,
+			branch,
 			check_runs,
 			pull_requests
 		});

package/src/lib/fs_fetch_value_cache.ts

@@ -27,7 +27,7 @@ export interface FetchCache {
  * 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.
+ * Formatted with gro's `format_file` before writing for version control friendliness.
  *
  * @param name - cache filename (without .json extension)
  * @param dir - cache directory (defaults to `.gro/build/fetch/`)