OrgMaintenanceScripts.jl

Documentation for OrgMaintenanceScripts.

Package Features

This package provides maintenance scripts for SciML organization repositories, including:

  • Code Formatting: Automated formatting with JuliaFormatter across entire organizations
  • Version Bumping: Automatically bump minor versions in Project.toml files
  • Package Registration: Register packages to Julia registries
  • Minimum Version Fixing: Fix minimum version compatibility bounds to pass downgrade CI tests
  • Compat Bumping: Automatically update package compatibility bounds for dependencies
  • Version Check Finding: Find outdated VERSION checks that can be removed
  • Invalidation Analysis: Use SnoopCompileCore to detect performance bottlenecks
  • Import Timing Analysis: Analyze package loading times with @time_imports
  • Explicit Imports Fixing: Automatically fix implicit imports and remove unused imports
  • Organization-wide Operations: Process entire organizations at once

Usage Examples

Code Formatting

using OrgMaintenanceScripts

# Format a single repository
success, message, pr_url = format_repository(
    "https://github.com/SciML/Example.jl.git";
    fork_user = "myusername"
)

# Format all repos with failing CI
successes, failures, pr_urls = format_org_repositories(
    "SciML";
    fork_user = "myusername",
    only_failing_ci = true
)

Version Bumping and Registration

using OrgMaintenanceScripts

# Bump minor versions and register all packages in a repository
result = bump_and_register_repo("/path/to/repo")

println("Registered packages: ", result.registered)
println("Failed packages: ", result.failed)

# Process all repositories in the SciML organization
results = bump_and_register_org("SciML"; auth_token="your_github_token")

for (repo, result) in results
    println("$repo:")
    println("  Registered: ", result.registered)
    println("  Failed: ", result.failed)
end

Minimum Version Fixing

using OrgMaintenanceScripts

# Fix minimum versions for a single repository
success = fix_repo_min_versions("SciML/OrdinaryDiffEq.jl")

# Fix all repositories in an organization
results = fix_org_min_versions("SciML")

# Process only specific repositories
results = fix_org_min_versions("SciML"; only_repos=["OrdinaryDiffEq.jl", "DiffEqBase.jl"])

Compat Bumping

using OrgMaintenanceScripts

# Check available compat updates for a repository
updates = get_available_compat_updates("/path/to/MyPackage.jl")
for (pkg, info) in updates
    println("$pkg: $(info.current) → $(info.latest)")
end

# Bump compat bounds and test
success = bump_compat_and_test("/path/to/MyPackage.jl"; 
    create_pr = true,
    fork_user = "myusername"
)

# Process an entire organization
results = bump_compat_org_repositories("SciML";
    fork_user = "myusername",
    limit = 10
)

Version Check Finding

using OrgMaintenanceScripts

# Find old version checks in a repository
checks = find_version_checks_in_repo("/path/to/MyPackage.jl")

# Find old version checks across an organization
results = find_version_checks_in_org("SciML"; min_version=v"1.10")
print_version_check_summary(results)

# Use custom minimum version
results = find_version_checks_in_org("MyOrg"; min_version=v"1.9", max_repos=10)

Explicit Imports Fixing

using OrgMaintenanceScripts

# Fix explicit imports in a package
success, iterations, report = fix_explicit_imports("/path/to/MyPackage.jl")

# Fix and create PR for a repository
fix_repo_explicit_imports("MyOrg/MyPackage.jl"; create_pr=true)

# Fix all packages in an organization
results = fix_org_explicit_imports("MyOrg"; create_prs=true)

Contents

API Reference

OrgMaintenanceScripts.analyze_invalidations_in_process — Function
analyze_invalidations_in_process(repo_path::String, test_script::String="")

Run invalidation analysis in a separate Julia process to avoid contaminating the current session. Returns invalidation data that can be analyzed to find major invalidators.

source
OrgMaintenanceScripts.analyze_org_import_timing — Method
analyze_org_import_timing(org::String; auth_token::String="", work_dir::String=mktempdir(), 
                         output_dir::String="", max_repos::Int=0)

Analyze import timing across all repositories in a GitHub organization.

source
OrgMaintenanceScripts.analyze_org_invalidations — Method
analyze_org_invalidations(org::String; auth_token::String="", work_dir::String=mktempdir(), 
                         test_script::String="", output_dir::String="", max_repos::Int=0)

Analyze invalidations across all repositories in a GitHub organization.

source
OrgMaintenanceScripts.bump_and_register_org — Method
bump_and_register_org(org::String; 
                     registry_url="https://github.com/JuliaRegistries/General",
                     auth_token::String="",
                     work_dir::String=mktempdir())

Bump minor versions and register all packages in all repositories of a GitHub organization.

source
OrgMaintenanceScripts.bump_and_register_repo — Method
bump_and_register_repo(repo_path::String; registry_url="https://github.com/JuliaRegistries/General")

Bump minor versions and register all packages in a repository. This handles the main Project.toml and all lib/*/Project.toml files.

source
OrgMaintenanceScripts.bump_compat_and_test — Method
bump_compat_and_test(repo_path::String;
                    package_name::Union{String,Nothing} = nothing,
                    bump_all::Bool = false,
                    create_pr::Bool = true,
                    fork_user::String = "")

Bump compat entries for major version updates and run tests. If tests pass, optionally create a PR.

Arguments

  • repo_path: Path to the repository
  • package_name: Specific package to bump (if nothing, check all)
  • bump_all: Whether to bump all available updates or just one
  • create_pr: Whether to create a PR if tests pass
  • fork_user: GitHub username for creating PRs (required if create_pr=true)

Returns

  • (success::Bool, message::String, pr_url::Union{String,Nothing}, bumped_packages::Vector{String})
source
OrgMaintenanceScripts.bump_compat_and_test_all — Method
bump_compat_and_test_all(repo_path::String;
                        package_name::Union{String,Nothing} = nothing,
                        bump_all::Bool = false,
                        create_pr::Bool = true,
                        fork_user::String = "",
                        include_subpackages::Bool = true)

Bump compat entries for major version updates in all Project.toml files in a repository. This function supports repositories with subpackages in the /lib directory.

Arguments

  • repo_path: Path to the repository
  • package_name: Specific package to bump across all Project.toml files
  • bump_all: Whether to bump all available updates or just one per Project.toml
  • create_pr: Whether to create a PR if tests pass
  • fork_user: GitHub username for creating PRs (required if create_pr=true)
  • include_subpackages: Whether to include subpackages in /lib directory

Returns

  • (success::Bool, message::String, pr_url::Union{String,Nothing}, bumped_info::Dict)
source
OrgMaintenanceScripts.bump_compat_org_repositories — Function
bump_compat_org_repositories(org::String = "SciML";
                            package_name::Union{String,Nothing} = nothing,
                            bump_all::Bool = false,
                            create_pr::Bool = true,
                            fork_user::String = "",
                            limit::Int = 100,
                            log_file::String = "",
                            include_subpackages::Bool = true)

Bump compat entries for all repositories in a GitHub organization. This function now supports repositories with subpackages in /lib directories.

Arguments

  • org: GitHub organization name (default: "SciML")
  • package_name: Specific package to bump across all repos (if nothing, check all)
  • bump_all: Whether to bump all available updates or just one per repo
  • create_pr: Whether to create PRs if tests pass
  • fork_user: GitHub username for creating PRs (required if create_pr=true)
  • limit: Maximum number of repositories to process
  • log_file: Path to save results log (default: auto-generated)
  • include_subpackages: Whether to include subpackages in /lib directories

Returns

  • (successes::Vector{String}, failures::Vector{String}, pr_urls::Vector{String})
source
OrgMaintenanceScripts.downgrade_to_minimum_versions — Method
downgrade_to_minimum_versions(project_dir::String; julia_version="1.10", mode="alldeps", work_dir=mktempdir())

Downgrade all dependencies to their minimum compatible versions using Resolver.jl. This uses the same approach as julia-actions/julia-downgrade-compat. Returns (success::Bool, output::String)

source
OrgMaintenanceScripts.find_version_checks_in_org — Method
find_version_checks_in_org(org::String; 
                          min_version::VersionNumber=JULIA_LTS,
                          auth_token::String="",
                          work_dir::String=mktempdir(),
                          ignore_dirs=["test", "docs", ".git"])

Find all version checks in all repositories of a GitHub organization.

source
OrgMaintenanceScripts.find_version_checks_in_repo — Method
find_version_checks_in_repo(repo_path::String; min_version::VersionNumber=JULIA_LTS, ignore_dirs=["test", "docs", ".git"])

Find all version checks in a repository that compare against versions older than min_version.

source
OrgMaintenanceScripts.fix_explicit_imports — Method
fix_explicit_imports(package_path::String; max_iterations=10, verbose=true)

Iteratively fix explicit import issues in a package until all checks pass. Returns (success::Bool, iterations::Int, final_report::String)

source
OrgMaintenanceScripts.fix_org_explicit_imports — Method
fix_org_explicit_imports(org_name::String;
                        work_dir=mktempdir(),
                        max_iterations=10,
                        create_prs=true,
                        skip_repos=String[],
                        only_repos=nothing,
                        verbose=true)

Fix explicit imports for all Julia packages in a GitHub organization.

source
OrgMaintenanceScripts.fix_org_min_versions — Method
fix_org_min_versions(org_name::String;
                    work_dir=mktempdir(),
                    max_iterations=10,
                    create_prs=true,
                    skip_repos=String[],
                    only_repos=nothing,
                    julia_version="1.10",
                    include_subpackages=true)

Fix minimum versions for all Julia packages in a GitHub organization. Now supports repositories with subpackages in /lib directories.

source
OrgMaintenanceScripts.fix_org_version_checks_parallel — Function
fix_org_version_checks_parallel(org::String, n_processes::Int=4;
                               min_version::VersionNumber=JULIA_LTS,
                               github_token::String="",
                               base_branch::String="main",
                               work_dir::String=mktempdir())

Find and fix version checks across an entire GitHub organization using parallel processing.

source
OrgMaintenanceScripts.fix_package_min_versions — Method
fix_package_min_versions(repo_path::String; 
                        max_iterations=10, 
                        work_dir=mktempdir(),
                        julia_version="1.10")

Fix minimum versions for a package repository that's already cloned. Returns (success::Bool, updates::Dict{String,String})

source
OrgMaintenanceScripts.fix_package_min_versions_all — Method
fix_package_min_versions_all(repo_path::String;
                            max_iterations=10,
                            work_dir=mktempdir(),
                            julia_version="1.10",
                            include_subpackages=true)

Fix minimum versions for all Project.toml files in a repository. Supports repositories with subpackages in the /lib directory. Returns (success::Bool, all_updates::Dict{String,Dict{String,String}})

source
OrgMaintenanceScripts.fix_repo_min_versions — Method
fix_repo_min_versions(repo_name::String;
                     work_dir=mktempdir(),
                     max_iterations=10,
                     create_pr=true,
                     julia_version="1.10",
                     include_subpackages=true)

Clone a repository, fix its minimum versions, and optionally create a PR. Now supports repositories with subpackages in /lib directories.

source
OrgMaintenanceScripts.fix_version_checks_parallel — Function
fix_version_checks_parallel(checks::Vector{VersionCheck}, n_processes::Int=4; 
                           github_token::String="", 
                           base_branch::String="main",
                           pr_title_prefix::String="[Auto] Remove obsolete version checks")

Fix version checks in parallel using N processes. Each process will create a PR to fix the version checks by removing obsolete comparisons.

source
OrgMaintenanceScripts.format_org_repositories — Function
format_org_repositories(org::String = "SciML";
                       test::Bool = true,
                       push_to_master::Bool = false,
                       create_pr::Bool = true,
                       fork_user::String = "",
                       limit::Int = 100,
                       only_failing_ci::Bool = true,
                       log_file::String = "")

Format all repositories in a GitHub organization.

Arguments

  • org: GitHub organization name (default: "SciML")
  • test: Whether to run tests after formatting (default: true)
  • push_to_master: Whether to push directly to master/main if tests pass (default: false)
  • create_pr: Whether to create PRs instead of pushing to master (default: true)
  • fork_user: GitHub username for creating PRs (required if create_pr=true)
  • limit: Maximum number of repositories to process (default: 100)
  • only_failing_ci: Only process repos with failing formatter CI (default: true)
  • log_file: Path to save results log (default: auto-generated)

Returns

  • (successes::Vector{String}, failures::Vector{String}, pr_urls::Vector{String})
source
OrgMaintenanceScripts.format_repository — Method
format_repository(repo_url::String; 
                 test::Bool = true,
                 push_to_master::Bool = false,
                 create_pr::Bool = true,
                 fork_user::String = "",
                 working_dir::String = mktempdir())

Format a single repository with JuliaFormatter.

Arguments

  • repo_url: URL of the repository to format (e.g., "https://github.com/SciML/Example.jl.git")
  • test: Whether to run tests after formatting (default: true)
  • push_to_master: Whether to push directly to master/main if tests pass (default: false)
  • create_pr: Whether to create a PR instead of pushing to master (default: true)
  • fork_user: GitHub username for creating PRs (required if create_pr=true)
  • working_dir: Directory to clone the repository into (default: temporary directory)

Returns

  • (success::Bool, message::String, pr_url::Union{String,Nothing})
source
OrgMaintenanceScripts.run_explicit_imports_check_all — Method
run_explicit_imports_check_all(repo_path::String; verbose=true, include_subpackages=true)

Run ExplicitImports.jl checks on all packages in a repository. Supports repositories with subpackages in /lib directories. Returns a Dict mapping relative paths to (success, report, issues) tuples.

source
OrgMaintenanceScripts.test_min_versions — Method
test_min_versions(project_dir::String; julia_version="1.10", mode="alldeps", work_dir=mktempdir())

Test if minimum versions can be resolved using Resolver.jl. Returns (success::Bool, error_output::String)

source
OrgMaintenanceScripts.update_project_versions_all — Method
update_project_versions_all(repo_path::String; include_subpackages::Bool=true)

Update the version in all Project.toml files in a repository by bumping the minor version. Supports repositories with subpackages in /lib directories. Returns a Dict mapping relative paths to (oldversion, newversion) tuples.

source