@fuzdev/fuz_gitops 0.57.0

package/dist/dependency_graph.js

@@ -0,0 +1,341 @@
+/**
+ * Dependency graph data structure and algorithms for multi-repo publishing.
+ *
+ * Provides `DependencyGraph` class with topological sort and cycle detection.
+ * For validation workflow and publishing order computation, see `graph_validation.ts`.
+ */
+import { EMPTY_OBJECT } from '@fuzdev/fuz_util/object.js';
+export const DEPENDENCY_TYPE = {
+    PROD: 'prod',
+    PEER: 'peer',
+    DEV: 'dev',
+};
+export class DependencyGraph {
+    nodes;
+    edges; // pkg -> dependents
+    constructor() {
+        this.nodes = new Map();
+        this.edges = new Map();
+    }
+    init_from_repos(repos) {
+        // First pass: create nodes
+        for (const repo of repos) {
+            const { library } = repo;
+            const node = {
+                name: library.name,
+                version: library.package_json.version || '0.0.0',
+                repo,
+                dependencies: new Map(),
+                dependents: new Set(),
+                publishable: !!library.package_json.private === false, // eslint-disable-line @typescript-eslint/no-unnecessary-boolean-literal-compare
+            };
+            // Extract dependencies
+            const deps = library.package_json.dependencies || EMPTY_OBJECT;
+            const dev_deps = library.package_json.devDependencies || EMPTY_OBJECT;
+            const peer_deps = library.package_json.peerDependencies || EMPTY_OBJECT;
+            // 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 });
+            }
+            for (const [name, version] of Object.entries(peer_deps)) {
+                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
+                if (!node.dependencies.has(name)) {
+                    node.dependencies.set(name, { type: DEPENDENCY_TYPE.DEV, version });
+                }
+            }
+            this.nodes.set(library.name, node);
+            this.edges.set(library.name, new Set());
+        }
+        // Second pass: build edges (dependents)
+        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);
+                    dep_node.dependents.add(node.name);
+                    this.edges.get(dep_name).add(node.name);
+                }
+            }
+        }
+    }
+    get_node(name) {
+        return this.nodes.get(name);
+    }
+    get_dependents(name) {
+        return this.edges.get(name) || new Set();
+    }
+    get_dependencies(name) {
+        const node = this.nodes.get(name);
+        return node ? node.dependencies : new Map();
+    }
+    /**
+     * Computes topological sort order for dependency graph.
+     *
+     * Uses Kahn's algorithm with alphabetical ordering within tiers for
+     * deterministic results. Throws if cycles detected.
+     *
+     * @param exclude_dev if true, excludes dev dependencies to break cycles.
+     *   Publishing uses exclude_dev=true to handle circular dev deps.
+     * @returns array of package names in dependency order (dependencies before dependents)
+     * @throws {Error} if circular dependencies detected in included dependency types
+     */
+    topological_sort(exclude_dev = false) {
+        const visited = new Set();
+        const result = [];
+        // Count incoming edges for each node
+        const in_degree = new Map();
+        for (const name of this.nodes.keys()) {
+            in_degree.set(name, 0);
+        }
+        for (const node of this.nodes.values()) {
+            for (const [dep_name, spec] of node.dependencies) {
+                // Skip dev dependencies if requested
+                if (exclude_dev && spec.type === DEPENDENCY_TYPE.DEV)
+                    continue;
+                if (this.nodes.has(dep_name)) {
+                    in_degree.set(node.name, in_degree.get(node.name) + 1);
+                }
+            }
+        }
+        // Start with nodes that have no dependencies
+        const queue = [];
+        for (const [name, degree] of in_degree) {
+            if (degree === 0) {
+                queue.push(name);
+            }
+        }
+        // Sort initial queue alphabetically for deterministic ordering within tier
+        queue.sort();
+        // Process nodes
+        while (queue.length > 0) {
+            const name = queue.shift();
+            result.push(name);
+            visited.add(name);
+            // Reduce in-degree for dependents
+            const node = this.nodes.get(name);
+            if (node) {
+                // Find packages that depend on this one
+                // Sort nodes to ensure deterministic iteration order
+                const sorted_nodes = Array.from(this.nodes.values()).sort((a, b) => a.name.localeCompare(b.name));
+                for (const other_node of sorted_nodes) {
+                    for (const [dep_name, spec] of other_node.dependencies) {
+                        // Skip dev dependencies if requested
+                        if (exclude_dev && spec.type === DEPENDENCY_TYPE.DEV)
+                            continue;
+                        if (dep_name === name) {
+                            const new_degree = in_degree.get(other_node.name) - 1;
+                            in_degree.set(other_node.name, new_degree);
+                            if (new_degree === 0) {
+                                queue.push(other_node.name);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        // Check for cycles
+        if (result.length !== this.nodes.size) {
+            const unvisited = Array.from(this.nodes.keys()).filter((n) => !visited.has(n));
+            throw new Error(`Circular dependency detected involving: ${unvisited.join(', ')}`);
+        }
+        return result;
+    }
+    detect_cycles() {
+        const cycles = [];
+        const visited = new Set();
+        const rec_stack = new Set();
+        const dfs = (name, path) => {
+            visited.add(name);
+            rec_stack.add(name);
+            path.push(name);
+            const node = this.nodes.get(name);
+            if (node) {
+                for (const [dep_name] of node.dependencies) {
+                    if (this.nodes.has(dep_name)) {
+                        if (!visited.has(dep_name)) {
+                            dfs(dep_name, [...path]);
+                        }
+                        else if (rec_stack.has(dep_name)) {
+                            // Found a cycle
+                            const cycle_start = path.indexOf(dep_name);
+                            cycles.push(path.slice(cycle_start).concat(dep_name));
+                        }
+                    }
+                }
+            }
+            rec_stack.delete(name);
+        };
+        for (const name of this.nodes.keys()) {
+            if (!visited.has(name)) {
+                dfs(name, []);
+            }
+        }
+        return cycles;
+    }
+    /**
+     * Detects circular dependencies, categorized by severity.
+     *
+     * Production/peer cycles prevent publishing (impossible to order packages).
+     * Dev cycles are normal (test utils, shared configs) and safely ignored.
+     *
+     * Uses DFS traversal with recursion stack to identify back edges.
+     * Deduplicates cycles using sorted cycle keys.
+     *
+     * @returns object with production_cycles (errors) and dev_cycles (info)
+     */
+    detect_cycles_by_type() {
+        const production_cycles = [];
+        const dev_cycles = [];
+        const visited_prod = new Set();
+        const visited_dev = new Set();
+        const rec_stack_prod = new Set();
+        const rec_stack_dev = new Set();
+        // DFS for production/peer dependencies only
+        const dfs_prod = (name, path) => {
+            visited_prod.add(name);
+            rec_stack_prod.add(name);
+            path.push(name);
+            const node = this.nodes.get(name);
+            if (node) {
+                for (const [dep_name, spec] of node.dependencies) {
+                    // Skip dev dependencies
+                    if (spec.type === DEPENDENCY_TYPE.DEV)
+                        continue;
+                    if (this.nodes.has(dep_name)) {
+                        if (!visited_prod.has(dep_name)) {
+                            dfs_prod(dep_name, [...path]);
+                        }
+                        else if (rec_stack_prod.has(dep_name)) {
+                            // Found a production cycle
+                            const cycle_start = path.indexOf(dep_name);
+                            const cycle = path.slice(cycle_start).concat(dep_name);
+                            // Check if this cycle is unique
+                            const cycle_key = [...cycle].sort().join(',');
+                            const exists = production_cycles.some((c) => [...c].sort().join(',') === cycle_key);
+                            if (!exists) {
+                                production_cycles.push(cycle);
+                            }
+                        }
+                    }
+                }
+            }
+            rec_stack_prod.delete(name);
+        };
+        // DFS for dev dependencies only
+        const dfs_dev = (name, path) => {
+            visited_dev.add(name);
+            rec_stack_dev.add(name);
+            path.push(name);
+            const node = this.nodes.get(name);
+            if (node) {
+                for (const [dep_name, spec] of node.dependencies) {
+                    // Only check dev dependencies
+                    if (spec.type !== DEPENDENCY_TYPE.DEV)
+                        continue;
+                    if (this.nodes.has(dep_name)) {
+                        if (!visited_dev.has(dep_name)) {
+                            dfs_dev(dep_name, [...path]);
+                        }
+                        else if (rec_stack_dev.has(dep_name)) {
+                            // Found a dev cycle
+                            const cycle_start = path.indexOf(dep_name);
+                            const cycle = path.slice(cycle_start).concat(dep_name);
+                            // Check if this cycle is unique
+                            const cycle_key = [...cycle].sort().join(',');
+                            const exists = dev_cycles.some((c) => [...c].sort().join(',') === cycle_key);
+                            if (!exists) {
+                                dev_cycles.push(cycle);
+                            }
+                        }
+                    }
+                }
+            }
+            rec_stack_dev.delete(name);
+        };
+        // Check for production/peer cycles
+        for (const name of this.nodes.keys()) {
+            if (!visited_prod.has(name)) {
+                dfs_prod(name, []);
+            }
+        }
+        // Check for dev cycles
+        for (const name of this.nodes.keys()) {
+            if (!visited_dev.has(name)) {
+                dfs_dev(name, []);
+            }
+        }
+        return { production_cycles, dev_cycles };
+    }
+    toJSON() {
+        const nodes = Array.from(this.nodes.values()).map((node) => ({
+            name: node.name,
+            version: node.version,
+            dependencies: Array.from(node.dependencies.entries()).map(([name, spec]) => ({
+                name,
+                spec,
+            })),
+            dependents: Array.from(node.dependents),
+            publishable: node.publishable,
+        }));
+        const edges = [];
+        for (const [from, tos] of this.edges) {
+            for (const to of tos) {
+                edges.push({ from, to });
+            }
+        }
+        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) {
+        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) {
+        return graph.topological_sort(true); // Exclude dev dependencies
+    }
+    analyze(graph) {
+        const { production_cycles, dev_cycles } = graph.detect_cycles_by_type();
+        const wildcard_deps = [];
+        const missing_peers = [];
+        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/dist/dependency_updater.d.ts

@@ -0,0 +1,46 @@
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { LocalRepo } from './local_repo.js';
+import type { PublishedVersion } from './multi_repo_publisher.js';
+import type { GitOperations, FsOperations } from './operations.js';
+export type VersionStrategy = 'exact' | 'caret' | 'tilde' | 'gte';
+export interface UpdatePackageJsonOptions {
+    strategy?: VersionStrategy;
+    published_versions?: Map<string, PublishedVersion>;
+    log?: Logger;
+    git_ops?: GitOperations;
+    fs_ops?: FsOperations;
+}
+/**
+ * Updates package.json dependencies and creates changeset if needed.
+ *
+ * Workflow:
+ * 1. Updates all dependency types (dependencies, devDependencies, peerDependencies)
+ * 2. Writes updated package.json with tabs formatting
+ * 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
+ * existing prefixes when possible.
+ *
+ * @throws {Error} if file operations or git operations fail
+ */
+export declare const update_package_json: (repo: LocalRepo, updates: Map<string, string>, options?: UpdatePackageJsonOptions) => Promise<void>;
+export interface UpdateAllReposOptions {
+    strategy?: VersionStrategy;
+    log?: Logger;
+    git_ops?: GitOperations;
+    fs_ops?: FsOperations;
+}
+export declare const update_all_repos: (repos: Array<LocalRepo>, published: Map<string, string>, options?: UpdateAllReposOptions) => Promise<{
+    updated: number;
+    failed: Array<{
+        repo: string;
+        error: Error;
+    }>;
+}>;
+export declare const find_updates_needed: (repo: LocalRepo, published: Map<string, string>) => Map<string, {
+    current: string;
+    new: string;
+    type: "dependencies" | "devDependencies" | "peerDependencies";
+}>;
+//# sourceMappingURL=dependency_updater.d.ts.map

package/dist/dependency_updater.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dependency_updater.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/dependency_updater.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAGpD,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAC/C,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,2BAA2B,CAAC;AAMhE,OAAO,KAAK,EAAC,aAAa,EAAE,YAAY,EAAC,MAAM,iBAAiB,CAAC;AAGjE,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,KAAK,CAAC;AAElE,MAAM,WAAW,wBAAwB;IACxC,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IACnD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,MAAM,CAAC,EAAE,YAAY,CAAC;CACtB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,mBAAmB,GAC/B,MAAM,SAAS,EACf,SAAS,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC5B,UAAS,wBAA6B,KACpC,OAAO,CAAC,IAAI,CAkId,CAAC;AAEF,MAAM,WAAW,qBAAqB;IACrC,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,aAAa,CAAC;IACxB,MAAM,CAAC,EAAE,YAAY,CAAC;CACtB;AAED,eAAO,MAAM,gBAAgB,GAC5B,OAAO,KAAK,CAAC,SAAS,CAAC,EACvB,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAC9B,UAAS,qBAA0B,KACjC,OAAO,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,KAAK,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,CAAA;KAAC,CAAC,CAAA;CAAC,CAuDxE,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAC/B,MAAM,SAAS,EACf,WAAW,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,KAC5B,GAAG,CACL,MAAM,EACN;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,cAAc,GAAG,iBAAiB,GAAG,kBAAkB,CAAA;CAAC,CAkD7F,CAAC"}

package/dist/dependency_updater.js

@@ -0,0 +1,213 @@
+import { join } from 'node:path';
+import { create_changeset_for_dependency_updates, create_dependency_updates, } from './changeset_generator.js';
+import { needs_update, get_update_prefix } from './version_utils.js';
+import { default_git_operations, default_fs_operations } from './operations_defaults.js';
+/**
+ * Updates package.json dependencies and creates changeset if needed.
+ *
+ * Workflow:
+ * 1. Updates all dependency types (dependencies, devDependencies, peerDependencies)
+ * 2. Writes updated package.json with tabs formatting
+ * 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
+ * existing prefixes when possible.
+ *
+ * @throws {Error} if file operations or git operations fail
+ */
+export const update_package_json = async (repo, updates, options = {}) => {
+    const { strategy = 'caret', published_versions, log, git_ops = default_git_operations, fs_ops = default_fs_operations, } = options;
+    if (updates.size === 0)
+        return;
+    const package_json_path = join(repo.repo_dir, 'package.json');
+    // Read current package.json
+    const content_result = await fs_ops.readFile({ path: package_json_path, encoding: 'utf8' });
+    if (!content_result.ok) {
+        throw new Error(`Failed to read package.json: ${content_result.message}`);
+    }
+    const package_json = JSON.parse(content_result.value);
+    // Apply version strategy
+    const prefix = strategy === 'exact' ? '' : strategy === 'caret' ? '^' : strategy === 'gte' ? '>=' : '~';
+    let updated = false;
+    // Update dependencies
+    if (package_json.dependencies) {
+        for (const [name, version] of updates) {
+            if (name in package_json.dependencies) {
+                const current = package_json.dependencies[name];
+                const update_prefix = get_update_prefix(current, prefix);
+                package_json.dependencies[name] = update_prefix + version;
+                updated = true;
+            }
+        }
+    }
+    // Update devDependencies
+    if (package_json.devDependencies) {
+        for (const [name, version] of updates) {
+            if (name in package_json.devDependencies) {
+                const current = package_json.devDependencies[name];
+                const update_prefix = get_update_prefix(current, prefix);
+                package_json.devDependencies[name] = update_prefix + version;
+                updated = true;
+            }
+        }
+    }
+    // Update peerDependencies
+    if (package_json.peerDependencies) {
+        for (const [name, version] of updates) {
+            if (name in package_json.peerDependencies) {
+                const current = package_json.peerDependencies[name];
+                const update_prefix = get_update_prefix(current, prefix);
+                package_json.peerDependencies[name] = update_prefix + version;
+                updated = true;
+            }
+        }
+    }
+    if (!updated)
+        return;
+    // Write updated package.json
+    const write_result = await fs_ops.writeFile({
+        path: package_json_path,
+        content: JSON.stringify(package_json, null, '\t') + '\n',
+    });
+    if (!write_result.ok) {
+        throw new Error(`Failed to write package.json: ${write_result.message}`);
+    }
+    // Create changeset if we have published version info
+    if (published_versions && published_versions.size > 0) {
+        // Build dependency updates info for changeset
+        const all_deps = new Map();
+        // Collect all current dependencies with their versions
+        if (repo.dependencies) {
+            for (const [name, version] of repo.dependencies) {
+                if (updates.has(name)) {
+                    all_deps.set(name, version);
+                }
+            }
+        }
+        if (repo.dev_dependencies) {
+            for (const [name, version] of repo.dev_dependencies) {
+                if (updates.has(name)) {
+                    all_deps.set(name, version);
+                }
+            }
+        }
+        if (repo.peer_dependencies) {
+            for (const [name, version] of repo.peer_dependencies) {
+                if (updates.has(name)) {
+                    all_deps.set(name, version);
+                }
+            }
+        }
+        const dependency_updates = create_dependency_updates(all_deps, published_versions);
+        if (dependency_updates.length > 0) {
+            const changeset_path = await create_changeset_for_dependency_updates(repo, dependency_updates, { log });
+            // Add changeset to git
+            const add_result = await git_ops.add({ files: changeset_path, cwd: repo.repo_dir });
+            if (!add_result.ok) {
+                throw new Error(`Failed to stage changeset: ${add_result.message}`);
+            }
+        }
+    }
+    // Commit the changes (including both package.json and changeset)
+    const add_pkg_result = await git_ops.add({ files: 'package.json', cwd: repo.repo_dir });
+    if (!add_pkg_result.ok) {
+        throw new Error(`Failed to stage package.json: ${add_pkg_result.message}`);
+    }
+    const commit_result = await git_ops.commit({
+        message: `update dependencies after publishing`,
+        cwd: repo.repo_dir,
+    });
+    if (!commit_result.ok) {
+        throw new Error(`Failed to commit: ${commit_result.message}`);
+    }
+};
+export const update_all_repos = async (repos, published, options = {}) => {
+    const { strategy = 'caret', log, git_ops = default_git_operations, fs_ops = default_fs_operations, } = options;
+    let updated_count = 0;
+    const failed = [];
+    for (const repo of repos) {
+        const updates = new Map();
+        // Find dependencies that were published
+        if (repo.dependencies) {
+            for (const [dep_name] of repo.dependencies) {
+                const new_version = published.get(dep_name);
+                if (new_version) {
+                    updates.set(dep_name, new_version);
+                }
+            }
+        }
+        if (repo.dev_dependencies) {
+            for (const [dep_name] of repo.dev_dependencies) {
+                const new_version = published.get(dep_name);
+                if (new_version) {
+                    updates.set(dep_name, new_version);
+                }
+            }
+        }
+        if (repo.peer_dependencies) {
+            for (const [dep_name] of repo.peer_dependencies) {
+                const new_version = published.get(dep_name);
+                if (new_version) {
+                    updates.set(dep_name, new_version);
+                }
+            }
+        }
+        if (updates.size === 0)
+            continue;
+        try {
+            await update_package_json(repo, updates, { strategy, log, git_ops, fs_ops }); // eslint-disable-line no-await-in-loop
+            updated_count++;
+            log?.info(`    Updated ${updates.size} dependencies in ${repo.library.name}`);
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            failed.push({ repo: repo.library.name, error: err });
+            log?.error(`    Failed to update ${repo.library.name}: ${err.message}`);
+        }
+    }
+    return { updated: updated_count, failed };
+};
+export const find_updates_needed = (repo, published) => {
+    const updates = new Map();
+    // Check dependencies
+    if (repo.dependencies) {
+        for (const [dep_name, current_version] of repo.dependencies) {
+            const new_version = published.get(dep_name);
+            if (new_version && needs_update(current_version, new_version)) {
+                updates.set(dep_name, {
+                    current: current_version,
+                    new: new_version,
+                    type: 'dependencies',
+                });
+            }
+        }
+    }
+    // Check devDependencies
+    if (repo.dev_dependencies) {
+        for (const [dep_name, current_version] of repo.dev_dependencies) {
+            const new_version = published.get(dep_name);
+            if (new_version && needs_update(current_version, new_version)) {
+                updates.set(dep_name, {
+                    current: current_version,
+                    new: new_version,
+                    type: 'devDependencies',
+                });
+            }
+        }
+    }
+    // Check peerDependencies
+    if (repo.peer_dependencies) {
+        for (const [dep_name, current_version] of repo.peer_dependencies) {
+            const new_version = published.get(dep_name);
+            if (new_version && needs_update(current_version, new_version)) {
+                updates.set(dep_name, {
+                    current: current_version,
+                    new: new_version,
+                    type: 'peerDependencies',
+                });
+            }
+        }
+    }
+    return updates;
+};

package/dist/fetch_repo_data.d.ts

@@ -0,0 +1,19 @@
+import type { Logger } from '@fuzdev/fuz_util/log.js';
+import type { FetchValueCache } from '@fuzdev/fuz_util/fetch.js';
+import type { RepoJson } from './repo.svelte.js';
+import type { LocalRepo } from './local_repo.js';
+/**
+ * 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.
+ *
+ * @param delay milliseconds between API requests (default: 33ms)
+ * @param cache optional cache from belt's fetch.js for response memoization
+ * @returns array of Repo objects with GitHub metadata attached
+ */
+export declare const fetch_repo_data: (resolved_repos: Array<LocalRepo>, token?: string, cache?: FetchValueCache, log?: Logger, delay?: number, github_api_version?: string) => Promise<Array<RepoJson>>;
+//# sourceMappingURL=fetch_repo_data.d.ts.map

package/dist/fetch_repo_data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch_repo_data.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/fetch_repo_data.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,yBAAyB,CAAC;AAEpD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,2BAA2B,CAAC;AAG/D,OAAO,KAAK,EAAC,QAAQ,EAAC,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAC,SAAS,EAAC,MAAM,iBAAiB,CAAC;AAI/C;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,GAC3B,gBAAgB,KAAK,CAAC,SAAS,CAAC,EAChC,QAAQ,MAAM,EACd,QAAQ,eAAe,EACvB,MAAM,MAAM,EACZ,cAAU,EACV,qBAAqB,MAAM,KACzB,OAAO,CAAC,KAAK,CAAC,QAAQ,CAAC,CAiCzB,CAAC"}

package/dist/fetch_repo_data.js

@@ -0,0 +1,49 @@
+import { wait } from '@fuzdev/fuz_util/async.js';
+import { fetch_github_check_runs, fetch_github_pull_requests } from './github.js';
+/* eslint-disable no-await-in-loop */
+/**
+ * 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.
+ *
+ * @param delay milliseconds between API requests (default: 33ms)
+ * @param cache optional cache from belt's fetch.js for response memoization
+ * @returns array of Repo objects with GitHub metadata attached
+ */
+export const fetch_repo_data = async (resolved_repos, token, cache, log, delay = 33, github_api_version) => {
+    const repos = [];
+    for (const { library, library_json, repo_config } of resolved_repos) {
+        const repo_url = library.repo_url;
+        // 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);
+        // pull requests
+        await wait(delay);
+        const pull_requests = await fetch_github_pull_requests(library, {
+            cache,
+            log,
+            token,
+            api_version: github_api_version,
+        });
+        if (!pull_requests)
+            log?.error('failed to fetch issues: ' + repo_url);
+        repos.push({
+            library_json,
+            check_runs,
+            pull_requests,
+        });
+    }
+    return repos;
+};