tasks: add the lint task

Author: nyonson

Cargo.lock

@@ -0,0 +1,5 @@
+# Changelog
+
+## [0.1.0] -
+
+* Initial release of `bitcoin-maintainer-tools` (executable: `bmt`) 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 = "bmt"
+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,56 @@
 # Maintainer Tools
 
 Maintainer tools for Rust-based projects in the Bitcoin domain. Built with [xshell](https://github.com/matklad/xshell).
+
+## Commands
+
+### `lint`
+
+Run comprehensive linting checks across the workspace and crates. 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
+
+* `BMT_LOG_LEVEL=quiet` - Suppress verbose output and reduce cargo noise.
+
+## Integration
+
+There are a few options to integrate with your workspace.
+
+### 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
+bmt 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]
+bitcoin-maintainer-tools = "0.1.0"
+```
+
+Then run via cargo.
+
+```bash
+cargo run --bin bmt -- 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 bmt from the local path.
+install:
+    cargo install --path .

tasks/justfile

@@ -0,0 +1,81 @@
+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 = "BMT_LOG_LEVEL";
+
+/// Helper macro to create commands that respect quiet mode.
+/// 
+/// Wraps xshell's `cmd!` macro and automatically adds `.quiet()` when `BMT_LOG_LEVEL=quiet`.
+#[macro_export]
+macro_rules! quiet_cmd {
+    ($sh:expr, $($arg:tt)*) => {{
+        let mut cmd = xshell::cmd!($sh, $($arg)*);
+        if std::env::var("BMT_LOG_LEVEL").map(|v| v == "quiet").unwrap_or(false) {
+            cmd = cmd.quiet();
+        }
+        cmd
+    }};
+}
+
+/// Print a message unless in quiet mode.
+pub fn println_verbose(msg: &str) {
+    if !is_quiet_mode() {
+        println!("{}", msg);
+    }
+}
+
+/// Check if we're in quiet mode via environment variable.
+fn is_quiet_mode() -> bool {
+    env::var(LOG_LEVEL_ENV_VAR)
+        .map(|v| v == "quiet")
+        .unwrap_or(false)
+}
+
+/// 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,123 @@
+use std::fs;
+use xshell::Shell;
+
+use crate::environment::{get_crate_dirs, println_verbose};
+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>> {
+    println_verbose("Running lint task...");
+
+    lint_workspace(sh)?;
+    lint_crates(sh)?;
+    check_duplicate_deps(sh)?;
+
+    println_verbose("Lint task completed successfully");
+    Ok(())
+}
+
+/// Lint the workspace with clippy.
+fn lint_workspace(sh: &Shell) -> Result<(), Box<dyn std::error::Error>> {
+    println_verbose("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>> {
+    println_verbose("Running crate-specific lints...");
+
+    let crate_dirs = get_crate_dirs(sh)?;
+    println_verbose(&format!("Found crates: {}", crate_dirs.join(", ")));
+
+    for crate_dir in crate_dirs {
+        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>> {
+    println_verbose("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() {
+        println_verbose(&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() {
+        eprintln!("Error: Found duplicate dependencies in workspace!");
+        for dup in &duplicates {
+            eprintln!("  {}", dup);
+        }
+        // Show full tree for context.
+        quiet_cmd!(sh, "cargo tree --target=all --all-features --duplicates").run()?;
+        return Err("Dependency tree contains duplicates".into());
+    }
+
+    println_verbose("No duplicate dependencies found");
+    Ok(())
+}

tasks/src/lint.rs

@@ -0,0 +1,38 @@
+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 = "bmt")]
+#[command(about = "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);
+            }
+        }
+    }
+}