forge/

main.rs

//! Command-line workspace profiling, auditing, and comparison tools.

mod allocation;
mod audit;
mod bench;
mod compare;
mod compare_matrix;
mod constants;
mod encounter_debug;
mod encounter_fixture;
mod encounter_html;
mod envelope;
mod gen_rotation_schema;
mod intent;
mod items;
mod manifest_ledger;
mod paperdoll;
mod parcel;
mod profile;
mod provider;
mod render;
mod report;
mod run;
mod sim;
mod simc;
mod spell_fixtures;
mod talent_attribute_summary;
mod talent_aura_summary;
mod talent_conformance;
mod talent_effect_summary;
mod talent_modifier_summary;
mod talent_target_flag_summary;
mod talent_target_plan_summary;
mod trace;
mod wowlab;

#[global_allocator]
static GLOBAL: allocation::CountingAllocator<mimalloc::MiMalloc> =
    allocation::CountingAllocator::new(mimalloc::MiMalloc);

use clap::{Parser, Subcommand};
use wowlab_common::{cli, output};

fn fatal(args: std::fmt::Arguments<'_>) -> ! {
    output::error(&format!("{args}"));
    std::process::exit(1);
}

#[derive(Parser)]
#[command(name = "forge", about = "Workspace profiler and comparison tools.")]
struct Args {
    #[command(subcommand)]
    command: Command,

    /// Suppress non-essential output.
    #[arg(long, short, global = true)]
    quiet: bool,
}

#[derive(Subcommand)]
enum Command {
    /// Benchmark engine throughput across specs, output HTML report.
    Bench(bench::BenchArgs),
    /// Compare `WoW` Lab engine output against `SimC`.
    Compare(compare::CompareArgs),
    /// Compare `WoW` Lab against `SimC` across every supported spec.
    CompareMatrix(compare_matrix::CompareMatrixArgs),
    /// Run a v2 intent envelope through the browser-preview engine path.
    Envelope(envelope::EnvelopeArgs),
    /// Profile a workspace crate with samply.
    Profile(profile::ProfileArgs),
    /// Audit spec manifests against game data.
    Audit(audit::AuditArgs),
    /// Dump the character sheet for a spec (stats, auras, gear).
    Paperdoll(paperdoll::PaperdollArgs),
    /// Measure each registered item's DPS contribution for a spec.
    Items(items::ItemsArgs),
    /// Inventory authored manifest and hook behavior at operation granularity.
    ManifestLedger(manifest_ledger::ManifestLedgerArgs),
    /// Encode, decode, and inspect LibParcel-1.0 envelopes.
    Parcel(parcel::ParcelArgs),
    /// Generate golden spell-description render fixtures for the regression suites.
    GenSpellFixtures(spell_fixtures::GenSpellFixturesArgs),
    /// Emit the rotation DSL JSON Schema (engine source of truth) for the AI edge function.
    GenRotationSchema(gen_rotation_schema::GenRotationSchemaArgs),
    /// Compare normalized MID2 talent records against `SimulationCraft`.
    TalentConformance(talent_conformance::TalentConformanceArgs),
}

#[cfg(test)]
mod tests {
    use clap::Parser;
    use googletest::{Result as GtestResult, prelude::*};

    use super::{Args, Command, encounter_fixture::EncounterFixture};

    #[gtest]
    fn both_fixture_commands_accept_every_canonical_slug() -> GtestResult<()> {
        let fixtures = [
            ("two_target_pack", EncounterFixture::TwoTargetPack),
            ("boss_add_wave", EncounterFixture::BossAddWave),
            ("two_pull_dungeon", EncounterFixture::TwoPullDungeon),
        ];

        for (slug, expected) in fixtures {
            let compare = Args::try_parse_from([
                "forge",
                "compare",
                "feral_druid",
                "--encounter-fixture",
                slug,
            ])
            .or_fail()?;
            let Command::Compare(compare) = compare.command else {
                return fail!("compare command expected");
            };

            verify_that!(compare.encounter_fixture, eq(Some(expected)))?;

            let paperdoll = Args::try_parse_from([
                "forge",
                "paperdoll",
                "feral_druid",
                "--encounter-fixture",
                slug,
            ])
            .or_fail()?;
            let Command::Paperdoll(paperdoll) = paperdoll.command else {
                return fail!("paperdoll command expected");
            };

            verify_that!(paperdoll.encounter_fixture, eq(Some(expected)))?;
        }

        Ok(())
    }

    #[gtest]
    fn paperdoll_rejects_an_unknown_encounter_fixture() -> GtestResult<()> {
        let result = Args::try_parse_from([
            "forge",
            "paperdoll",
            "feral_druid",
            "--encounter-fixture",
            "invented_pack",
        ]);
        let error = result.err().or_fail()?;

        verify_true!(error.to_string().contains("invalid value 'invented_pack'"))?;

        Ok(())
    }

    #[gtest]
    fn envelope_accepts_browser_reproduction_inputs() -> GtestResult<()> {
        let parsed = Args::try_parse_from([
            "forge",
            "envelope",
            "/tmp/outlaw.toml",
            "--rotation",
            "/tmp/outlaw.json",
            "--seed",
            "123",
            "--decision-limit",
            "50",
            "--trace",
        ])
        .or_fail()?;
        let Command::Envelope(envelope) = parsed.command else {
            return fail!("envelope command expected");
        };

        verify_that!(
            envelope.envelope.as_path(),
            eq(wowlab_fs::path::Path::new("/tmp/outlaw.toml"))
        )?;
        verify_that!(
            envelope.rotation.as_deref(),
            eq(Some(wowlab_fs::path::Path::new("/tmp/outlaw.json")))
        )?;
        verify_that!(envelope.seed, eq(123))?;
        verify_that!(envelope.decision_limit, eq(50))?;
        verify_true!(envelope.trace)?;

        Ok(())
    }
}

#[cfg(test)]
mod run_parameter_cli_tests {
    use clap::Parser;
    use googletest::{Result as GtestResult, prelude::*};

    use super::{Args, Command, run::RunParameters};

    fn command_run_parameters(command: &Command) -> Option<RunParameters> {
        match command {
            Command::Compare(args) => RunParameters::try_from(args).ok(),
            Command::CompareMatrix(args) => RunParameters::try_from(args).ok(),
            Command::Bench(args) => RunParameters::try_from(args).ok(),
            Command::Items(args) => RunParameters::try_from(args).ok(),
            Command::Profile(args) => RunParameters::try_from(args).ok(),
            _ => None,
        }
    }

    #[gtest]
    fn run_command_defaults_remain_command_specific() -> GtestResult<()> {
        let cases = [
            (["forge", "compare", "fire_mage"].as_slice(), 1, 300),
            (["forge", "compare-matrix"].as_slice(), 1, 300),
            (["forge", "bench"].as_slice(), 500_000, 300),
            (["forge", "items"].as_slice(), 100, 60),
            (["forge", "profile"].as_slice(), 5_000, 300),
        ];

        for (arguments, iterations, duration) in cases {
            let parsed = Args::try_parse_from(arguments).or_fail()?;
            let parameters = command_run_parameters(&parsed.command).or_fail()?;

            verify_that!(parameters.iterations(), eq(iterations))?;
            verify_that!(parameters.fight_duration_secs(), eq(duration))?;
        }

        Ok(())
    }

    #[gtest]
    fn run_commands_reject_zero_values_at_the_typed_boundary() -> GtestResult<()> {
        let zero_iterations = [
            ["forge", "compare", "fire_mage", "--iterations", "0"].as_slice(),
            ["forge", "compare-matrix", "--iterations", "0"].as_slice(),
            ["forge", "bench", "--iterations", "0"].as_slice(),
            ["forge", "items", "--iterations", "0"].as_slice(),
            ["forge", "profile", "--iterations", "0"].as_slice(),
        ];

        for arguments in zero_iterations {
            let parsed = Args::try_parse_from(arguments).or_fail()?;
            let error = match &parsed.command {
                Command::Compare(args) => RunParameters::try_from(args).err().or_fail()?,
                Command::CompareMatrix(args) => RunParameters::try_from(args).err().or_fail()?,
                Command::Bench(args) => RunParameters::try_from(args).err().or_fail()?,
                Command::Items(args) => RunParameters::try_from(args).err().or_fail()?,
                Command::Profile(args) => RunParameters::try_from(args).err().or_fail()?,
                _ => return fail!("command has no shared run parameters"),
            };

            verify_that!(
                error.to_string(),
                eq("iterations must be greater than zero")
            )?;
        }

        Ok(())
    }
}

#[cfg(test)]
mod summary_command_tests {
    use clap::Parser;
    use googletest::{Result as GtestResult, prelude::*};

    use super::{Args, Command, run::RunParameters};

    #[gtest]
    fn compare_matrix_accepts_filters_and_shared_run_parameters() -> GtestResult<()> {
        let parsed = Args::try_parse_from([
            "forge",
            "compare-matrix",
            "fire_mage",
            "unholy_death_knight",
            "--duration",
            "60",
            "--iterations",
            "20",
            "--jobs",
            "2",
            "--format",
            "json",
        ])
        .or_fail()?;
        let Command::CompareMatrix(matrix) = parsed.command else {
            return fail!("compare-matrix command expected");
        };

        verify_that!(
            matrix
                .specs
                .iter()
                .map(AsRef::as_ref)
                .collect::<Vec<&str>>(),
            elements_are![eq(&"fire_mage"), eq(&"unholy_death_knight")]
        )?;
        verify_that!(
            &matrix,
            matches_pattern!(crate::compare_matrix::CompareMatrixArgs {
                duration: eq(&60),
                iterations: eq(&20),
                jobs: eq(&2),
                ..
            })
        )?;
        let parameters = RunParameters::try_from(&matrix).or_fail()?;

        verify_that!(parameters.iterations(), eq(20))?;
        verify_that!(parameters.fight_duration_secs(), eq(60))?;

        Ok(())
    }
}

fn main() {
    let args = Args::parse();
    let _composition = wowlab_engine::composition::EngineComposition::initialize()
        .unwrap_or_else(|error| fatal(format_args!("{error}")));
    let app = cli::boot("forge", env!("CARGO_PKG_VERSION"), args.quiet, "FORGE_ROOT");

    match args.command {
        Command::Bench(ref bench_args) => {
            if let Err(e) = bench::run(bench_args) {
                fatal(format_args!("{e}"));
            }
        }
        Command::Compare(ref compare_args) => {
            if let Err(e) = compare::run(compare_args) {
                fatal(format_args!("{e:#}"));
            }
        }
        Command::CompareMatrix(ref matrix_args) => {
            if let Err(e) = compare_matrix::run(matrix_args) {
                fatal(format_args!("{e:#}"));
            }
        }
        Command::Envelope(ref envelope_args) => {
            if let Err(e) = envelope::run(envelope_args) {
                fatal(format_args!("{e:#}"));
            }
        }
        Command::Profile(ref profile_args) => {
            let crates_dir = app.crates_dir();

            profile::run(profile_args, &crates_dir);
        }
        Command::Audit(ref audit_args) => {
            if let Err(e) = audit::run(audit_args) {
                fatal(format_args!("{e}"));
            }
        }
        Command::Paperdoll(ref pd_args) => {
            if let Err(e) = paperdoll::run(pd_args) {
                fatal(format_args!("{e:#}"));
            }
        }
        Command::Items(ref items_args) => {
            if let Err(e) = items::run(items_args) {
                fatal(format_args!("{e:#}"));
            }
        }
        Command::ManifestLedger(ref ledger_args) => {
            if let Err(e) = manifest_ledger::run(ledger_args) {
                fatal(format_args!("{e:#}"));
            }
        }
        Command::Parcel(ref parcel_args) => {
            if let Err(e) = parcel::run(parcel_args) {
                fatal(format_args!("{e:#}"));
            }
        }
        Command::GenSpellFixtures(ref gen_args) => {
            if let Err(e) = spell_fixtures::run(gen_args) {
                fatal(format_args!("{e:#}"));
            }
        }
        Command::GenRotationSchema(ref gen_args) => {
            if let Err(e) = gen_rotation_schema::run(gen_args) {
                fatal(format_args!("{e:#}"));
            }
        }
        Command::TalentConformance(ref conformance_args) => {
            if let Err(e) = talent_conformance::run(conformance_args) {
                fatal(format_args!("{e:#}"));
            }
        }
    }
}