Crate releasaurus_core 

releasaurus-core

Core library powering Releasaurus release automation. Use this crate to embed the full release pipeline in your own Rust tooling without taking a dependency on the CLI binary.

Architecture

Orchestrator        (pipeline entry point)
  └─ OrchestratorConfig   (merged settings)
  └─ ForgeManager         (caching + dry-run wrapper)
       └─ Forge           (GitHub / GitLab / Gitea / Local)

Quick start

use std::{collections::HashMap, rc::Rc};
use releasaurus_core::{
    forge::{
        github::Github,
        manager::{ForgeManager, ForgeOptions},
        config::{RepoUrl, Scheme},
    },
    orchestrator::{
        Orchestrator,
        config::{
            CommitModifiers, GlobalOverrides, OrchestratorConfig,
        },
        package::resolved::{
            ResolvedPackage, ResolvedPackageHash,
        },
    },
};

#[tokio::main]
async fn main() -> releasaurus_core::error::Result<()> {
    let url = RepoUrl {
        scheme: Scheme::Https,
        host: "github.com".into(),
        owner: "my-org".into(),
        name: "my-repo".into(),
        path: "my-org/my-repo".into(),
        port: None,
        token: None,
    };

    // 1. Build a forge client.
    let forge = Github::new(url, None).await?;
    let forge_manager = ForgeManager::new(
        Box::new(forge),
        ForgeOptions { dry_run: false },
    );

    // 2. Load releasaurus.toml from the repository.
    let config = Rc::new(
        forge_manager.load_config(None).await?,
    );

    // 3. Build the orchestrator config.
    let orch_config = Rc::new(
        OrchestratorConfig::builder()
            .toml_config(Rc::clone(&config))
            .repo_name(forge_manager.repo_name())
            .repo_default_branch(
                forge_manager.default_branch(),
            )
            .release_link_base_url(
                forge_manager.release_link_base_url().clone(),
            )
            .compare_link_base_url(
                forge_manager.compare_link_base_url().clone(),
            )
            .global_overrides(GlobalOverrides::default())
            .package_overrides(HashMap::new())
            .commit_modifiers(CommitModifiers::default())
            .build()?,
    );

    // 4. Resolve each package declared in releasaurus.toml.
    let mut resolved = vec![];
    for pkg in config.packages.iter() {
        resolved.push(
            ResolvedPackage::builder()
                .orchestrator_config(Rc::clone(&orch_config))
                .package_config(pkg.clone())
                .build()?,
        );
    }

    // 5. Build the orchestrator and run the pipeline.
    let fm = Rc::new(forge_manager);
    let orchestrator = Orchestrator::builder()
        .config(Rc::clone(&orch_config))
        .package_configs(Rc::new(
            ResolvedPackageHash::new(resolved)?,
        ))
        .forge(Rc::clone(&fm))
        .build()?;

    orchestrator.create_release_prs(None).await
}

Modules

• analyzer — conventional commit parsing and version calculation
• config — TOML configuration types and deserialization
• error — ReleasaurusError and Result
• file_loader — trait for loading files from a forge or filesystem
• forge — Forge trait and platform implementations (GitHub, GitLab, Gitea, Local)
• orchestrator — all release operations flow through Orchestrator
• updater — language-specific version file updaters

Modules

analyzer

Commit analysis, version detection, and changelog generation.

config

Configuration loading and parsing for releasaurus.toml files.

error

Custom error types for Releasaurus with improved type safety and error handling.

file_loader

File loading abstraction for manifest content retrieval.

forge

Unified interface for Git forge platforms (GitHub, GitLab, Gitea).

orchestrator

updater

Manifest version updates for various programming languages and file types.