Step-by-Step: Build a 10K Star GitHub Repo with Rust 1.85 and Clap 4.5 to Get Hired in 2026

# Install Rust 1.85
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain 1.85.0
source $HOME/.cargo/env
rustc --version  # Should output rustc 1.85.0 (xxxxxx 2025-xx-xx)

cargo new rusty-grep --bin
cd rusty-grep

[package]
name = "rusty-grep"
version = "0.1.0"
edition = "2021"
authors = ["Your Name "]
description = "A fast, parallel grep alternative written in Rust"
license = "MIT"
repository = "https://github.com/yourusername/rusty-grep"
keywords = ["grep", "cli", "search", "parallel"]
categories = ["command-line-utilities"]

[dependencies]
clap = { version = "4.5.0", features = ["derive"] }
anyhow = "1.0.86"
rayon = "1.10.0"
memmap2 = "0.9.4"
regex = "1.10.4"
tracing = "0.1.40"
tracing-subscriber = { version = "0.3.18", features = ["env-filter"] }
indicatif = "0.17.8"
num_cpus = "1.16.0"
rustc_version = "0.4.0"

use anyhow::{Context, Result};
use clap::{Parser, Subcommand};
use tracing::info;

/// A fast, parallel grep alternative written in Rust 1.85
#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Search for a pattern in a file or directory
    Search {
        /// Regular expression pattern to search for
        #[arg(short, long)]
        pattern: String,
        /// Path to file or directory to search (defaults to current directory)
        #[arg(short, long, default_value = ".")]
        path: String,
        /// Enable parallel search (uses all available CPU cores)
        #[arg(short, long, default_value_t = false)]
        parallel: bool,
        /// Show line numbers in output
        #[arg(short, long, default_value_t = false)]
        line_numbers: bool,
    },
    /// Show configuration and system info
    Config,
}

fn main() -> Result<()> {
    // Initialize tracing for debug logging (enable with RUST_LOG=debug)
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
        .init();

    let cli = Cli::parse();
    info!("Parsed CLI arguments: {:?}", cli);

    match cli.command {
        Commands::Search {
            pattern,
            path,
            parallel,
            line_numbers,
        } => search(pattern, path, parallel, line_numbers)?,
        Commands::Config => show_config(),
    }

    Ok(())
}

fn search(pattern: String, path: String, parallel: bool, line_numbers: bool) -> Result<()> {
    // TODO: Implement search logic in next step
    info!(
        "Searching for pattern '{}' in path '{}' (parallel: {}, line numbers: {})",
        pattern, path, parallel, line_numbers
    );
    Ok(())
}

fn show_config() {
    println!("rusty-grep 0.1.0");
    println!("Rust version: {}", rustc_version::version().unwrap());
    println!("Available CPU cores: {}", num_cpus::get());
}

// src/search.rs
use anyhow::{Context, Result};
use memmap2::Mmap;
use rayon::prelude::*;
use regex::Regex;
use std::fs::{self, File};
use std::io::{BufRead, BufReader};
use std::path::{Path, PathBuf};
use tracing::{debug, error, info};

/// Recursively collect all files in a directory, skipping hidden files and build artifacts
pub fn collect_files(path: &Path) -> Result> {
    let mut files = Vec::new();
    let metadata = fs::metadata(path)
        .with_context(|| format!("Failed to read metadata for {}", path.display()))?;

    if metadata.is_file() {
        files.push(path.to_path_buf());
        return Ok(files);
    }

    if metadata.is_dir() {
        for entry in fs::read_dir(path)
            .with_context(|| format!("Failed to read directory {}", path.display()))?
        {
            let entry = entry?;
            let entry_path = entry.path();
            // Skip hidden files/directories (start with .)
            if entry_path
                .file_name()
                .map(|n| n.to_string_lossy().starts_with('.'))
                .unwrap_or(false)
            {
                debug!("Skipping hidden path: {}", entry_path.display());
                continue;
            }
            // Skip target directory (Cargo build artifacts)
            if entry_path.ends_with("target") {
                debug!("Skipping target directory: {}", entry_path.display());
                continue;
            }
            files.extend(collect_files(&entry_path)?);
        }
    }

    Ok(files)
}

/// Search a single file for a pattern, returning matching lines
pub fn search_file(
    file_path: &Path,
    pattern: &Regex,
    show_line_numbers: bool,
) -> Result> {
    let file = File::open(file_path)
        .with_context(|| format!("Failed to open file {}", file_path.display()))?;
    let mmap = unsafe {
        Mmap::map(&file)
            .with_context(|| format!("Failed to mmap file {}", file_path.display()))?
    };
    let content = std::str::from_utf8(&mmap)
        .with_context(|| format!("File {} is not valid UTF-8", file_path.display()))?;

    let mut matches = Vec::new();
    for (line_num, line) in content.lines().enumerate() {
        if pattern.is_match(line) {
            let match_line = if show_line_numbers {
                format!("{}:{}:{}", file_path.display(), line_num + 1, line)
            } else {
                format!("{}:{}", file_path.display(), line)
            };
            matches.push(match_line);
        }
    }

    debug!("Found {} matches in {}", matches.len(), file_path.display());
    Ok(matches)
}

/// Parallel search across all files using rayon
pub fn parallel_search(
    files: Vec,
    pattern: &Regex,
    show_line_numbers: bool,
) -> Result> {
    info!("Starting parallel search across {} files", files.len());
    let pattern = pattern.clone(); // Regex implements Clone + Sync, safe for parallel use
    let results: Vec>> = files
        .par_iter()
        .map(|file_path| search_file(file_path, &pattern, show_line_numbers))
        .collect();

    let mut all_matches = Vec::new();
    for result in results {
        match result {
            Ok(mut matches) => all_matches.append(&mut matches),
            Err(e) => error!("Search failed for file: {}", e),
        }
    }

    info!("Total matches found: {}", all_matches.len());
    Ok(all_matches)
}

use anyhow::{Context, Result};
use clap::{Parser, Subcommand};
use indicatif::{ProgressBar, ProgressStyle};
use num_cpus;
use regex::Regex;
use std::path::Path;
use std::process::Command;
use std::time::Instant;
use tracing::{info, warn};

mod search;

/// A fast, parallel grep alternative written in Rust 1.85
#[derive(Parser)]
#[command(version, about, long_about = None)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand)]
enum Commands {
    /// Search for a pattern in a file or directory
    Search {
        /// Regular expression pattern to search for
        #[arg(short, long)]
        pattern: String,
        /// Path to file or directory to search (defaults to current directory)
        #[arg(short, long, default_value = ".")]
        path: String,
        /// Enable parallel search (uses all available CPU cores)
        #[arg(short, long, default_value_t = true)]
        parallel: bool,
        /// Show line numbers in output
        #[arg(short, long, default_value_t = false)]
        line_numbers: bool,
    },
    /// Show configuration and system info
    Config,
    /// Run benchmarks against GNU grep
    Benchmark {
        /// Path to directory to benchmark (defaults to current directory)
        #[arg(short, long, default_value = ".")]
        path: String,
        /// Pattern to use for benchmarking
        #[arg(short, long, default_value = "rust")]
        pattern: String,
    },
}

fn main() -> Result<()> {
    tracing_subscriber::fmt()
        .with_env_filter(tracing_subscriber::EnvFilter::from_default_env())
        .init();

    let cli = Cli::parse();
    info!("Parsed CLI arguments: {:?}", cli);

    match cli.command {
        Commands::Search {
            pattern,
            path,
            parallel,
            line_numbers,
        } => run_search(pattern, path, parallel, line_numbers)?,
        Commands::Config => show_config(),
        Commands::Benchmark { path, pattern } => run_benchmark(path, pattern)?,
    }

    Ok(())
}

fn run_search(pattern: String, path: String, parallel: bool, line_numbers: bool) -> Result<()> {
    let start = Instant::now();
    let regex = Regex::new(&pattern)
        .with_context(|| format!("Invalid regular expression: {}", pattern))?;
    info!("Compiled regex pattern: {}", pattern);

    let files = search::collect_files(Path::new(&path))
        .with_context(|| format!("Failed to collect files from {}", path))?;
    info!("Collected {} files to search", files.len());

    if files.is_empty() {
        warn!("No files found to search in {}", path);
        return Ok(());
    }

    let pb = ProgressBar::new(files.len() as u64);
    pb.set_style(
        ProgressStyle::default_bar()
            .template("{spinner:.green} [{elapsed_precise}] [{bar:40.cyan/blue}] {pos}/{len} files (matches: {msg})")?
            .progress_chars("#>-"),
    );

    let matches = if parallel {
        // Update progress bar for parallel search (approximate)
        pb.set_message("0");
        let result = search::parallel_search(files, ®ex, line_numbers)?;
        pb.finish_with_message(format!("{}", result.len()));
        result
    } else {
        let mut all_matches = Vec::new();
        for file in files {
            pb.inc(1);
            let mut file_matches = search::search_file(&file, ®ex, line_numbers)?;
            pb.set_message(format!("{}", all_matches.len() + file_matches.len()));
            all_matches.append(&mut file_matches);
        }
        pb.finish_with_message(format!("{}", all_matches.len()));
        all_matches
    };

    for m in matches {
        println!("{}", m);
    }

    info!("Search completed in {:?}", start.elapsed());
    Ok(())
}

fn show_config() {
    println!("rusty-grep 0.2.0");
    println!("Rust version: {}", rustc_version::version().unwrap());
    println!("Available CPU cores: {}", num_cpus::get());
    println!("Clap version: 4.5.0");
}

fn run_benchmark(path: String, pattern: String) -> Result<()> {
    // Run rusty-grep benchmark
    let rusty_start = Instant::now();
    let rusty_output = Command::new("cargo")
        .args(["run", "--release", "--", "search", "-p", &pattern, "-P", &path])
        .output()
        .context("Failed to run rusty-grep benchmark")?;
    let rusty_duration = rusty_start.elapsed();
    let rusty_matches = String::from_utf8_lossy(&rusty_output.stdout)
        .lines()
        .count();

    // Run GNU grep benchmark
    let gnu_start = Instant::now();
    let gnu_output = Command::new("grep")
        .args(["-r", "-n", &pattern, &path])
        .output()
        .context("Failed to run GNU grep benchmark (ensure grep is installed)")?;
    let gnu_duration = gnu_start.elapsed();
    let gnu_matches = String::from_utf8_lossy(&gnu_output.stdout)
        .lines()
        .count();

    println!("Benchmark Results (path: {}, pattern: {})", path, pattern);
    println!("===========================================");
    println!("rusty-grep: {} matches in {:?}", rusty_matches, rusty_duration);
    println!("GNU grep:   {} matches in {:?}", gnu_matches, gnu_duration);
    println!(
        "Speedup:    {:.2}x",
        gnu_duration.as_secs_f64() / rusty_duration.as_secs_f64()
    );

    Ok(())
}

#[derive(Parser)]
struct Cli {
    #[arg(short, long)]
    verbose: bool,
}

use criterion::{black_box, Criterion};

fn bench_search(c: &mut Criterion) {
    c.bench_function("search 100MB file", |b| {
        b.iter(|| black_box(search_file("test.txt", ®ex)));
    });
}

name: CI
on: [push, pull_request]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: dtolnay/rust-toolchain@1.85.0
      - run: cargo test --release

rusty-grep/
├── Cargo.toml
├── src/
│   ├── main.rs
│   ├── search.rs
│   └── lib.rs
├── benches/
│   └── search_bench.rs
├── .github/
│   └── workflows/
│       ├── ci.yml
│       └── release.yml
├── README.md
├── LICENSE
└── .gitignore