feat(rust): port config simulate to native Rust (Phase 1.3b) (#1298)

Completes the config pilot. Second native command, flipped in
PORT_STATUS.toml from ``shimmed`` to ``native``.

## What ports natively

``mergify config simulate PULL_REQUEST_URL [-f PATH] [-t TOKEN] [-u URL]``:

1. Parses the PR URL into ``(owner/repo, number)``. Invalid URLs
   are rejected by clap's ``value_parser``, which exits 2 (matching
   Python's ``click.BadParameter``).
2. Resolves the config file (same three-location search as
   ``config validate`` — shared helper in ``paths.rs``).
3. Reads the YAML as a raw string (no parsing — the simulator API
   accepts the text verbatim).
4. Resolves the bearer token: explicit ``--token`` → ``MERGIFY_TOKEN``
   → ``GITHUB_TOKEN`` → error. Matches Python's precedence; the
   ``gh auth token`` subprocess fallback isn't ported yet.
5. Resolves the API URL: explicit ``--api-url`` → ``MERGIFY_API_URL``
   → ``https://api.mergify.com`` default.
6. POSTs ``{"mergify_yml": <content>}`` to
   ``/v1/repos/<repo>/pulls/<number>/simulator`` via the 1.2b HTTP
   client (auth + retry + typed errors).
7. Prints the returned title + summary to stdout.

Rich Markdown rendering of ``summary`` is deliberately deferred —
we print raw Markdown today. Human output drift is allowed by the
compat contract; machine-readable paths aren't affected because
``config simulate`` has no ``--json`` flag in Python either.

## Dispatch

``mergify-cli/src/main.rs`` now carries two clap subcommands
(``validate`` + ``simulate``). The dispatch logic got a light
reshape: on clap parse failure we distinguish "obvious native
intent" (argv contains ``config`` + one of ``validate``/``simulate``)
from "unrecognized command, fall through". Native-intent parse
errors surface clap's formatted error and exit 2; anything else
falls through to the Python shim so unported commands keep working.

## Refactor

The config-path resolver moved from ``validate.rs`` into a shared
``paths.rs`` module so both commands share a single source of
truth for the ``[".mergify.yml", ".mergify/config.yml",
".github/mergify.yml"]`` search list.

## Tests

24 tests in ``mergify-config`` (up from 11 in Phase 1.3):

- 3 for the shared path resolver (moved out of ``validate.rs``)
- 6 for PR URL parsing (happy path + 5 rejection cases)
- 4 for token resolution (explicit, env fallback, error)
- 2 for API URL resolution
- 1 end-to-end wiremock test: POST + JSON body + auth header +
  response rendering

Covered by the port-inventory guard: ``PORT_STATUS.toml`` flips
``config simulate`` from ``shimmed`` to ``native``.

Binary size: 8.0 MB → 8.3 MB (small bump from simulate.rs).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: jd

Cargo.lock

@@ -53,7 +53,7 @@ status = "shimmed"
 
 [[command]]
 path = ["config", "simulate"]
-status = "shimmed"
+status = "native"
 
 [[command]]
 path = ["config", "validate"]

PORT_STATUS.toml

@@ -1,29 +1,34 @@
 //! `mergify` binary entry point.
 //!
-//! Dispatch logic:
-//! - If the invocation is `mergify config validate [--config-file
-//!   PATH]`, run it natively via `mergify_config::validate`.
-//! - Anything else is handed to `mergify_py_shim::run`, which
-//!   extracts the embedded Python source on first use and invokes
-//!   `python3 -m mergify_cli`.
+//! Dispatch logic: every invocation is speculatively parsed with
+//! clap, which knows about the native commands
+//! ([`ConfigSubcommand::Validate`], [`ConfigSubcommand::Simulate`]).
+//! If clap succeeds with a known native variant the binary runs
+//! that code path natively. Any parse failure — including
+//! subcommands clap doesn't know about (``stack push``, ``ci
+//! junit-process``, …) — falls through to [`mergify_py_shim::run`],
+//! which hands the original argv to ``python3 -m mergify_cli``.
 //!
-//! As each command ports (Phase 1.4+), native dispatch grows and
-//! the shim fallback shrinks. Phase 6 deletes the shim entirely.
+//! As each command ports (Phase 1.4+), new variants land on the
+//! clap enum and the shim fallback shrinks. Phase 6 deletes the
+//! shim entirely.
 
 use std::env;
 use std::path::PathBuf;
 use std::process::ExitCode;
 
 use clap::Parser;
 use clap::Subcommand;
+use mergify_config::simulate::PullRequestRef;
+use mergify_config::simulate::SimulateOptions;
 use mergify_core::OutputMode;
 use mergify_core::StdioOutput;
 
 fn main() -> ExitCode {
     let argv: Vec<String> = env::args().skip(1).collect();
 
-    if let Some(NativeCommand::ConfigValidate(opts)) = detect_native(&argv) {
-        return run_native_config_validate(&opts);
+    if let Some(cmd) = detect_native(&argv) {
+        return run_native(cmd);
     }
 
     match mergify_py_shim::run(&argv) {
@@ -35,7 +40,74 @@ fn main() -> ExitCode {
     }
 }
 
-fn run_native_config_validate(opts: &ConfigValidateOpts) -> ExitCode {
+/// Native commands the Rust binary handles without delegating to
+/// the Python shim.
+enum NativeCommand {
+    ConfigValidate { config_file: Option<PathBuf> },
+    ConfigSimulate(ConfigSimulateOpts),
+}
+
+struct ConfigSimulateOpts {
+    config_file: Option<PathBuf>,
+    pull_request: PullRequestRef,
+    token: Option<String>,
+    api_url: Option<String>,
+}
+
+/// Try to recognize the invocation as a native command.
+///
+/// Returns ``None`` when the argv doesn't look like a native
+/// command — callers fall back to the Python shim, which produces
+/// the same error messages as before the port started. When the
+/// argv obviously targets a native command (contains ``config``
+/// and ``validate``/``simulate``) but clap can't parse it — e.g.
+/// the user gave a bad flag or an invalid URL — this function
+/// prints clap's formatted error to stderr and exits the process
+/// with clap's exit code (2), matching the Python CLI's behavior
+/// for argument errors.
+fn detect_native(argv: &[String]) -> Option<NativeCommand> {
+    let looks_native = {
+        let has_config = argv.iter().any(|a| a == "config");
+        let has_native_sub = argv.iter().any(|a| a == "validate" || a == "simulate");
+        has_config && has_native_sub
+    };
+
+    let parsed = match CliRoot::try_parse_from(
+        std::iter::once("mergify".to_string()).chain(argv.iter().cloned()),
+    ) {
+        Ok(parsed) => parsed,
+        Err(err) if looks_native => {
+            // Native intent + clap rejection = surface clap's error
+            // and exit. ``err.exit()`` prints to stderr and calls
+            // ``process::exit``; does not return.
+            err.exit()
+        }
+        Err(_) => return None,
+    };
+
+    match parsed.command {
+        Subcommands::Config(ConfigArgs {
+            config_file,
+            command: ConfigSubcommand::Validate(_),
+        }) => Some(NativeCommand::ConfigValidate { config_file }),
+        Subcommands::Config(ConfigArgs {
+            config_file,
+            command:
+                ConfigSubcommand::Simulate(SimulateCliArgs {
+                    pull_request,
+                    token,
+                    api_url,
+                }),
+        }) => Some(NativeCommand::ConfigSimulate(ConfigSimulateOpts {
+            config_file,
+            pull_request,
+            token,
+            api_url,
+        })),
+    }
+}
+
+fn run_native(cmd: NativeCommand) -> ExitCode {
     let rt = match tokio::runtime::Builder::new_current_thread()
         .enable_all()
         .build()
@@ -48,68 +120,37 @@ fn run_native_config_validate(opts: &ConfigValidateOpts) -> ExitCode {
     };
 
     let mut output = StdioOutput::new(OutputMode::Human);
-    let result = rt.block_on(mergify_config::validate::run(
-        opts.config_file.as_deref(),
-        &mut output,
-    ));
+
+    let result = rt.block_on(async {
+        match cmd {
+            NativeCommand::ConfigValidate { config_file } => {
+                mergify_config::validate::run(config_file.as_deref(), &mut output).await
+            }
+            NativeCommand::ConfigSimulate(opts) => {
+                mergify_config::simulate::run(
+                    SimulateOptions {
+                        pull_request: &opts.pull_request,
+                        config_file: opts.config_file.as_deref(),
+                        token: opts.token.as_deref(),
+                        api_url: opts.api_url.as_deref(),
+                    },
+                    &mut output,
+                )
+                .await
+            }
+        }
+    });
 
     match result {
         Ok(()) => ExitCode::from(mergify_core::ExitCode::Success.as_u8()),
         Err(err) => {
             let code = err.exit_code();
-            // Commands that emit their own details through `Output`
-            // (e.g. `config validate`'s per-error list) still get a
-            // top-level "mergify: <message>" line appended, matching
-            // the Python CLI's behavior.
             eprintln!("mergify: {err}");
             ExitCode::from(code.as_u8())
         }
     }
 }
 
-/// Recognised native commands, paired with their pre-parsed options.
-enum NativeCommand {
-    ConfigValidate(ConfigValidateOpts),
-}
-
-#[derive(Debug, Default)]
-struct ConfigValidateOpts {
-    config_file: Option<PathBuf>,
-}
-
-/// Try to recognise the invocation as a native command. Returns
-/// `None` when the argv doesn't match any native command or when
-/// clap rejects it — in both cases the caller falls back to the
-/// Python shim (which produces the same error messages as before
-/// the port started).
-fn detect_native(argv: &[String]) -> Option<NativeCommand> {
-    // Quick cheap check: argv must contain "config" followed by
-    // "validate" to possibly be a native match. This avoids running
-    // clap on every command.
-    let has_config_validate = argv
-        .iter()
-        .position(|a| a == "config")
-        .is_some_and(|i| argv.get(i + 1).is_some_and(|a| a == "validate"));
-    if !has_config_validate {
-        return None;
-    }
-
-    match CliRoot::try_parse_from(
-        std::iter::once("mergify".to_string()).chain(argv.iter().cloned()),
-    ) {
-        Ok(CliRoot {
-            command:
-                Subcommands::Config(ConfigArgs {
-                    config_file,
-                    command: ConfigSubcommand::Validate(_),
-                }),
-        }) => Some(NativeCommand::ConfigValidate(ConfigValidateOpts {
-            config_file,
-        })),
-        _ => None,
-    }
-}
-
 #[derive(Parser)]
 #[command(name = "mergify", disable_help_subcommand = true)]
 #[command(disable_version_flag = true, disable_help_flag = true)]
@@ -139,7 +180,27 @@ struct ConfigArgs {
 enum ConfigSubcommand {
     /// Validate the Mergify configuration file against the schema.
     Validate(ValidateArgs),
+    /// Simulate Mergify actions on a pull request using the local
+    /// configuration.
+    Simulate(SimulateCliArgs),
 }
 
 #[derive(clap::Args)]
 struct ValidateArgs {}
+
+#[derive(clap::Args)]
+struct SimulateCliArgs {
+    /// Pull request URL (e.g. <https://github.com/owner/repo/pull/123>).
+    #[arg(value_name = "PULL_REQUEST_URL", value_parser = mergify_config::simulate::parse_pr_url)]
+    pull_request: PullRequestRef,
+
+    /// Mergify or GitHub token. Falls back to ``MERGIFY_TOKEN`` and
+    /// then ``GITHUB_TOKEN`` env vars.
+    #[arg(long, short = 't')]
+    token: Option<String>,
+
+    /// Mergify API URL. Falls back to ``MERGIFY_API_URL`` env var,
+    /// then to the default.
+    #[arg(long = "api-url", short = 'u')]
+    api_url: Option<String>,
+}

crates/mergify-cli/src/main.rs

@@ -19,6 +19,7 @@ url = "2"
 
 [dev-dependencies]
 tempfile = "3.14"
+temp-env = "0.3"
 tokio = { version = "1", default-features = false, features = ["macros", "rt", "time"] }
 wiremock = "0.6"
 

crates/mergify-config/Cargo.toml

@@ -1,6 +1,8 @@
 //! Native Rust implementation of the `mergify config` subcommands.
 //!
-//! Phase 1.3 ports `config validate`. `config simulate` stays in the
-//! Python shim until Phase 1.3b.
+//! Phase 1.3 ports `config validate`. Phase 1.3b adds `config
+//! simulate`. Both share the config-file resolver in [`paths`].
 
+pub mod paths;
+pub mod simulate;
 pub mod validate;

crates/mergify-config/src/lib.rs

@@ -0,0 +1,92 @@
+//! Shared helpers for resolving the Mergify configuration file path.
+//!
+//! Both `config validate` and `config simulate` accept a
+//! ``--config-file`` flag and otherwise auto-detect the file from a
+//! small list of conventional locations. The resolver here is the
+//! single source of truth for that behavior.
+
+use std::path::Path;
+use std::path::PathBuf;
+
+use mergify_core::CliError;
+
+/// Filename patterns the CLI searches for a Mergify configuration,
+/// in priority order. Mirrors ``MERGIFY_CONFIG_PATHS`` in
+/// ``mergify_cli/ci/detector.py``.
+pub const DEFAULT_CONFIG_PATHS: [&str; 3] =
+    [".mergify.yml", ".mergify/config.yml", ".github/mergify.yml"];
+
+/// Resolve the path of the Mergify configuration file relative to
+/// the current working directory.
+///
+/// When ``explicit`` is ``Some``, that path must be a real file —
+/// otherwise the user specified a bad path and we fail loudly with
+/// [`CliError::Configuration`]. When ``explicit`` is ``None`` the
+/// resolver walks [`DEFAULT_CONFIG_PATHS`] in order and returns the
+/// first match.
+pub fn resolve_config_path(explicit: Option<&Path>) -> Result<PathBuf, CliError> {
+    resolve_config_path_in(explicit, Path::new("."))
+}
+
+/// Same as [`resolve_config_path`] but searches relative to
+/// ``base`` instead of the current working directory.
+///
+/// Tests use this directly to avoid `std::env::set_current_dir`,
+/// which races with parallel cargo test workers in the same
+/// process.
+///
+/// # Errors
+///
+/// Returns [`CliError::Configuration`] when neither an explicit
+/// path nor any default candidate exists.
+pub fn resolve_config_path_in(explicit: Option<&Path>, base: &Path) -> Result<PathBuf, CliError> {
+    if let Some(path) = explicit {
+        if path.is_file() {
+            return Ok(path.to_path_buf());
+        }
+        return Err(CliError::Configuration(format!(
+            "Configuration file not found: {}",
+            path.display(),
+        )));
+    }
+    for candidate in DEFAULT_CONFIG_PATHS {
+        let path = base.join(candidate);
+        if path.is_file() {
+            return Ok(path);
+        }
+    }
+    Err(CliError::Configuration(format!(
+        "Mergify configuration file not found. Looked in: {}",
+        DEFAULT_CONFIG_PATHS.join(", "),
+    )))
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+
+    use super::*;
+
+    #[test]
+    fn finds_dotmergify_yml() {
+        let tmp = tempfile::tempdir().unwrap();
+        fs::write(tmp.path().join(".mergify.yml"), "").unwrap();
+        let got = resolve_config_path_in(None, tmp.path()).unwrap();
+        assert_eq!(got, tmp.path().join(".mergify.yml"));
+    }
+
+    #[test]
+    fn errors_when_no_file_and_no_explicit() {
+        let tmp = tempfile::tempdir().unwrap();
+        let err = resolve_config_path_in(None, tmp.path()).unwrap_err();
+        assert!(matches!(err, CliError::Configuration(_)));
+        assert!(err.to_string().contains("not found"));
+    }
+
+    #[test]
+    fn errors_on_explicit_missing_file() {
+        let err = resolve_config_path_in(Some(Path::new("/nonexistent/path.yml")), Path::new("."))
+            .unwrap_err();
+        assert!(matches!(err, CliError::Configuration(_)));
+    }
+}