tasks: add the lint task

Author: nyonson

Cargo.lock

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] -
+
+* Initial release of `rust-bitcoin-maintainer-tools` (executable: `rbmt`) matching functionality of shell scripts.

tasks/CHANGELOG.md

@@ -5,3 +5,14 @@ authors = ["Nick Johnson <[email protected]>"]
 license = "CC0-1.0"
 edition = "2021"
 rust-version = "1.74.0"
+
+[[bin]]
+name = "rbmt"
+path = "src/main.rs"
+
+[dependencies]
+xshell = "0.2"
+clap = { version = "4", features = ["derive"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+toml = "0.8"

tasks/Cargo.toml

@@ -1,3 +1,54 @@
 # Maintainer Tools
 
 Maintainer tools for Rust-based projects in the Bitcoin domain. Built with [xshell](https://github.com/matklad/xshell).
+
+## Configuration
+
+The `lint` command detects duplicate dependencies, but some may be unavoidable (e.g., during dependency updates where transitive dependencies haven't caught up). You can whitelist specific duplicates by creating a `contrib/whitelist_dups.toml` file.
+
+```toml
+# Allow specific duplicate dependencies.
+allowed_duplicates = [
+    "syn",
+    "bitcoin_hashes",
+]
+```
+
+### Environment Variables
+
+* `RBMT_LOG_LEVEL=quiet` - Suppress verbose output and reduce cargo noise.
+
+## Workspace Integration
+
+`rbmt` can simply be installed globally, or as a dev-dependency for more granular control of dependency versions.
+
+### 1. Install globally
+
+Install the tool globally on your system with `cargo install`.
+
+```bash
+cargo install [email protected]
+```
+
+Then run from anywhere in your repository.
+
+```bash
+rbmt lint
+```
+
+### 2. Add as a dev-dependency
+
+Add as a dev-dependency to a workspace member. This pins the tool version in your lockfile for reproducible builds.
+
+```toml
+[dev-dependencies]
+rust-bitcoin-maintainer-tools = "0.1.0"
+```
+
+Then run via cargo.
+
+```bash
+cargo run --bin rbmt -- lint
+```
+
+It might be worth wrapping in an [xtask](https://github.com/matklad/cargo-xtask) package for a clean interface.

tasks/README.md

@@ -0,0 +1,11 @@
+# List available recipes.
+_default:
+    @just --list
+
+# Run tests.
+test:
+    cargo test
+
+# Install rbmt from the local path.
+install:
+    cargo install --path .

tasks/justfile

@@ -0,0 +1,77 @@
+use std::env;
+use xshell::{cmd, Shell};
+
+/// Environment variable to control output verbosity.
+/// Set to "quiet" to suppress informational messages and reduce cargo output.
+/// Any other value (or unset) defaults to verbose mode.
+const LOG_LEVEL_ENV_VAR: &str = "RBMT_LOG_LEVEL";
+
+/// Check if we're in quiet mode via environment variable.
+pub fn is_quiet_mode() -> bool {
+    env::var(LOG_LEVEL_ENV_VAR).is_ok_and(|v| v == "quiet")
+}
+
+/// Helper macro to create commands that respect quiet mode.
+#[macro_export]
+macro_rules! quiet_cmd {
+    ($sh:expr, $($arg:tt)*) => {{
+        let mut cmd = xshell::cmd!($sh, $($arg)*);
+        if $crate::environment::is_quiet_mode() {
+            cmd = cmd.quiet();
+        }
+        cmd
+    }};
+}
+
+/// Print a message unless in quiet mode.
+pub fn quiet_println(msg: &str) {
+    if !is_quiet_mode() {
+        println!("{}", msg);
+    }
+}
+
+/// Configure shell log level and output verbosity.
+/// Sets cargo output verbosity based on LOG_LEVEL_ENV_VAR.
+pub fn configure_log_level(sh: &Shell) {
+    if is_quiet_mode() {
+        sh.set_var("CARGO_TERM_VERBOSE", "false");
+        sh.set_var("CARGO_TERM_QUIET", "true");
+    } else {
+        sh.set_var("CARGO_TERM_VERBOSE", "true");
+        sh.set_var("CARGO_TERM_QUIET", "false");
+    }
+}
+
+/// Change to the repository root directory.
+///
+/// # Panics
+///
+/// Panics if not in a git repository or git command fails.
+pub fn change_to_repo_root(sh: &Shell) {
+    let repo_dir = cmd!(sh, "git rev-parse --show-toplevel")
+        .read()
+        .expect("Failed to get repository root, ensure you're in a git repository");
+    sh.change_dir(&repo_dir);
+}
+
+/// Get list of crate directories in the workspace using cargo metadata.
+/// Returns fully qualified paths to support various workspace layouts including nested crates.
+pub fn get_crate_dirs(sh: &Shell) -> Result<Vec<String>, Box<dyn std::error::Error>> {
+    let metadata = cmd!(sh, "cargo metadata --no-deps --format-version 1").read()?;
+    let json: serde_json::Value = serde_json::from_str(&metadata)?;
+
+    let crate_dirs: Vec<String> = json["packages"]
+        .as_array()
+        .ok_or("Missing 'packages' field in cargo metadata")?
+        .iter()
+        .filter_map(|package| {
+            let manifest_path = package["manifest_path"].as_str()?;
+            // Extract directory path from the manifest path,
+            // e.g., "/path/to/repo/releases/Cargo.toml" -> "/path/to/repo/releases".
+            let dir_path = manifest_path.trim_end_matches("/Cargo.toml");
+            Some(dir_path.to_string())
+        })
+        .collect();
+
+    Ok(crate_dirs)
+}

tasks/src/environment.rs

@@ -0,0 +1,124 @@
+use std::fs;
+use xshell::Shell;
+
+use crate::environment::{get_crate_dirs, quiet_println};
+use crate::quiet_cmd;
+
+/// Configuration for allowed duplicate dependencies.
+#[derive(Debug, serde::Deserialize)]
+struct WhitelistConfig {
+    #[serde(default)]
+    allowed_duplicates: Vec<String>,
+}
+
+/// Run the lint task.
+pub fn run(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+    quiet_println("Running lint task...");
+
+    lint_workspace(sh)?;
+    lint_crates(sh)?;
+    check_duplicate_deps(sh)?;
+
+    quiet_println("Lint task completed successfully");
+    Ok(())
+}
+
+/// Lint the workspace with clippy.
+fn lint_workspace(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+    quiet_println("Linting workspace...");
+
+    // Run clippy on workspace with all features.
+    quiet_cmd!(
+        sh,
+        "cargo clippy --workspace --all-targets --all-features --keep-going"
+    )
+    .args(&["--", "-D", "warnings"])
+    .run()?;
+
+    // Run clippy on workspace without features.
+    quiet_cmd!(sh, "cargo clippy --workspace --all-targets --keep-going")
+        .args(&["--", "-D", "warnings"])
+        .run()?;
+
+    Ok(())
+}
+
+/// Run extra crate-specific lints.
+///
+/// # Why run at the crate level?
+///
+/// When running `cargo clippy --workspace --no-default-features`, cargo resolves
+/// features across the entire workspace, which can enable features through dependencies
+/// even when a crate's own default features are disabled. Running clippy on each crate
+/// individually ensures that each crate truly compiles and passes lints with only its
+/// explicitly enabled features.
+fn lint_crates(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+    quiet_println("Running crate-specific lints...");
+
+    let crate_dirs = get_crate_dirs(sh)?;
+    quiet_println(&format!("Found crates: {}", crate_dirs.join(", ")));
+
+    for crate_dir in crate_dirs {
+        // Returns a RAII guard which reverts the working directory to the old value when dropped.
+        let _old_dir = sh.push_dir(&crate_dir);
+
+        // Run clippy without default features.
+        quiet_cmd!(
+            sh,
+            "cargo clippy --all-targets --no-default-features --keep-going"
+        )
+        .args(&["--", "-D", "warnings"])
+        .run()?;
+    }
+
+    Ok(())
+}
+
+/// Check for duplicate dependencies.
+fn check_duplicate_deps(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+    quiet_println("Checking for duplicate dependencies...");
+
+    // Load whitelist configuration if it exists.
+    let whitelist_path = sh.current_dir().join("contrib/whitelist_dups.toml");
+    let allowed_duplicates = if whitelist_path.exists() {
+        quiet_println(&format!(
+            "Loading whitelist from {}",
+            whitelist_path.display()
+        ));
+        let contents = fs::read_to_string(&whitelist_path)?;
+        let config: WhitelistConfig = toml::from_str(&contents)?;
+        config.allowed_duplicates
+    } else {
+        Vec::new()
+    };
+
+    // Run cargo tree to find duplicates.
+    let output = quiet_cmd!(sh, "cargo tree --target=all --all-features --duplicates")
+        .ignore_status()
+        .read()?;
+
+    let duplicates: Vec<&str> = output
+        .lines()
+        // Filter out non crate names.
+        .filter(|line| line.chars().next().is_some_and(|c| c.is_alphanumeric()))
+        // Filter out whitelisted crates.
+        .filter(|line| {
+            !allowed_duplicates
+                .iter()
+                .any(|allowed| line.contains(allowed))
+        })
+        .collect();
+
+    if !duplicates.is_empty() {
+        // Show full tree for context.
+        quiet_cmd!(sh, "cargo tree --target=all --all-features --duplicates").run()?;
+        eprintln!("Error: Found duplicate dependencies in workspace!");
+        for dup in &duplicates {
+            eprintln!("  {}", dup);
+        }
+        return Err("Dependency tree contains duplicates".into());
+    }
+
+    quiet_println("No duplicate dependencies found");
+    Ok(())
+}

tasks/src/lint.rs

@@ -1 +1,38 @@
-fn main() {}
+mod environment;
+mod lint;
+
+use clap::{Parser, Subcommand};
+use std::process;
+use xshell::Shell;
+
+use environment::{change_to_repo_root, configure_log_level};
+
+#[derive(Parser)]
+#[command(name = "rbmt")]
+#[command(about = "Rust Bitcoin Maintainer Tools", long_about = None)]
+struct Cli {
+    #[command(subcommand)]
+    command: Commands,
+}
+
+#[derive(Subcommand)]
+enum Commands {
+    /// Run the linter (clippy) for workspace and all crates.
+    Lint,
+}
+
+fn main() {
+    let cli = Cli::parse();
+    let sh = Shell::new().unwrap();
+    configure_log_level(&sh);
+    change_to_repo_root(&sh);
+
+    match cli.command {
+        Commands::Lint => {
+            if let Err(e) = lint::run(&sh) {
+                eprintln!("Error running lint task: {}", e);
+                process::exit(1);
+            }
+        }
+    }
+}