feat(scaffold): initial Rust project structure (#29)

- Add Cargo.toml with dependencies (clap, serde, anyhow, thiserror, etc.)
- Add release profile optimized for binary size
- Add CLI argument parsing with clap derive
- Add rnr.yaml config parsing with serde
- Add task runner with support for:
  - Simple commands (shorthand syntax)
  - Full task definitions (cmd, dir, env, description)
  - Sequential steps
  - Nested task delegation
  - Parallel blocks (placeholder for async implementation)
- Add init command (creates .rnr/bin, wrapper scripts, starter config)
- Add upgrade command (placeholder for binary updates)
- Add list command (shows available tasks with descriptions)
- Add .gitignore for Rust artifacts

Author: CalvinAllen

.gitignore

@@ -0,0 +1,17 @@
+# Rust build artifacts
+/target/
+**/*.rs.bk
+Cargo.lock
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Test artifacts
+*.log

Cargo.toml

@@ -0,0 +1,42 @@
+[package]
+name = "rnr"
+version = "0.1.0"
+edition = "2021"
+description = "A cross-platform task runner with zero setup"
+license = "MIT"
+repository = "https://github.com/CodingWithCalvin/rnr.cli"
+keywords = ["task-runner", "build", "automation", "cli"]
+categories = ["command-line-utilities", "development-tools"]
+
+[dependencies]
+# CLI argument parsing
+clap = { version = "4", features = ["derive"] }
+
+# YAML parsing
+serde = { version = "1", features = ["derive"] }
+serde_yaml = "0.9"
+
+# Error handling
+anyhow = "1"
+thiserror = "1"
+
+# Cross-platform support
+dirs = "5"
+
+# HTTP client for init/upgrade
+reqwest = { version = "0.12", features = ["blocking"], default-features = false, optional = true }
+
+# Async runtime for parallel execution
+tokio = { version = "1", features = ["rt-multi-thread", "process", "sync"], optional = true }
+
+[features]
+default = ["network", "parallel"]
+network = ["reqwest"]
+parallel = ["tokio"]
+
+[profile.release]
+opt-level = "z"     # Optimize for size
+lto = true          # Link-time optimization
+codegen-units = 1   # Single codegen unit for better optimization
+panic = "abort"     # Abort on panic (smaller binary)
+strip = true        # Strip symbols

src/cli.rs

@@ -0,0 +1,27 @@
+use clap::{Parser, Subcommand};
+
+/// A cross-platform task runner with zero setup
+#[derive(Parser, Debug)]
+#[command(name = "rnr")]
+#[command(author, version, about, long_about = None)]
+pub struct Cli {
+    /// Task to run
+    #[arg(value_name = "TASK")]
+    pub task: Option<String>,
+
+    /// List all available tasks
+    #[arg(short, long)]
+    pub list: bool,
+
+    #[command(subcommand)]
+    pub command: Option<Command>,
+}
+
+#[derive(Subcommand, Debug)]
+pub enum Command {
+    /// Initialize rnr in the current directory
+    Init,
+
+    /// Upgrade rnr binaries to the latest version
+    Upgrade,
+}

src/commands/init.rs

@@ -0,0 +1,141 @@
+use anyhow::{Context, Result};
+use std::fs;
+use std::path::Path;
+
+use crate::config::CONFIG_FILE;
+
+/// Directory for rnr binaries
+const RNR_DIR: &str = ".rnr";
+const BIN_DIR: &str = "bin";
+
+/// Run the init command
+pub fn run() -> Result<()> {
+    let current_dir = std::env::current_dir().context("Failed to get current directory")?;
+
+    // Check if already initialized
+    let rnr_dir = current_dir.join(RNR_DIR);
+    if rnr_dir.exists() {
+        println!("rnr is already initialized in this directory");
+        return Ok(());
+    }
+
+    println!("Initializing rnr...");
+
+    // Create .rnr/bin directory
+    let bin_dir = rnr_dir.join(BIN_DIR);
+    fs::create_dir_all(&bin_dir).context("Failed to create .rnr/bin directory")?;
+    println!("  Created {}/{}", RNR_DIR, BIN_DIR);
+
+    // Download binaries for all platforms
+    #[cfg(feature = "network")]
+    {
+        download_binaries(&bin_dir)?;
+    }
+
+    #[cfg(not(feature = "network"))]
+    {
+        println!("  Skipping binary download (network feature disabled)");
+        println!("  Please manually copy binaries to {}/{}", RNR_DIR, BIN_DIR);
+    }
+
+    // Create wrapper scripts
+    create_wrapper_scripts(&current_dir)?;
+
+    // Create starter rnr.yaml if it doesn't exist
+    let config_path = current_dir.join(CONFIG_FILE);
+    if !config_path.exists() {
+        create_starter_config(&config_path)?;
+    } else {
+        println!("  {} already exists, skipping", CONFIG_FILE);
+    }
+
+    println!("\nrnr initialized successfully!");
+    println!("\nNext steps:");
+    println!("  1. Edit {} to define your tasks", CONFIG_FILE);
+    println!("  2. Run ./rnr --list to see available tasks");
+    println!("  3. Run ./rnr <task> to execute a task");
+    println!("  4. Commit the .rnr directory and wrapper scripts to your repo");
+
+    Ok(())
+}
+
+/// Download binaries for all platforms
+#[cfg(feature = "network")]
+fn download_binaries(bin_dir: &Path) -> Result<()> {
+    // TODO: Implement actual binary downloads from rnr.dev
+    // For now, just create placeholder files
+    println!("  Downloading binaries...");
+    println!("    TODO: Download from https://rnr.dev/bin/latest/");
+
+    // Placeholder - in real implementation, download from server
+    let platforms = ["rnr-linux", "rnr-macos", "rnr.exe"];
+    for platform in platforms {
+        let path = bin_dir.join(platform);
+        fs::write(&path, "# placeholder binary\n")
+            .with_context(|| format!("Failed to create {}", path.display()))?;
+        println!("    Created {}", platform);
+    }
+
+    Ok(())
+}
+
+/// Create the wrapper scripts at the project root
+fn create_wrapper_scripts(project_root: &Path) -> Result<()> {
+    // Unix wrapper script
+    let unix_script = r#"#!/bin/sh
+exec "$(dirname "$0")/.rnr/bin/rnr-$(uname -s | tr A-Z a-z)" "$@"
+"#;
+
+    let unix_path = project_root.join("rnr");
+    fs::write(&unix_path, unix_script).context("Failed to create rnr wrapper script")?;
+
+    // Make executable on Unix
+    #[cfg(unix)]
+    {
+        use std::os::unix::fs::PermissionsExt;
+        let mut perms = fs::metadata(&unix_path)?.permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(&unix_path, perms)?;
+    }
+
+    println!("  Created rnr (Unix wrapper)");
+
+    // Windows wrapper script
+    let windows_script = r#"@echo off
+"%~dp0.rnr\bin\rnr.exe" %*
+"#;
+
+    let windows_path = project_root.join("rnr.cmd");
+    fs::write(&windows_path, windows_script).context("Failed to create rnr.cmd wrapper script")?;
+    println!("  Created rnr.cmd (Windows wrapper)");
+
+    Ok(())
+}
+
+/// Create a starter rnr.yaml configuration
+fn create_starter_config(path: &Path) -> Result<()> {
+    let starter = r#"# rnr task definitions
+# See https://github.com/CodingWithCalvin/rnr.cli for documentation
+
+# Simple command (shorthand)
+hello: echo "Hello from rnr!"
+
+# Full task definition
+build:
+  description: Build the project
+  cmd: echo "Add your build command here"
+
+# Task with steps
+ci:
+  description: Run CI pipeline
+  steps:
+    - cmd: echo "Step 1: Lint"
+    - cmd: echo "Step 2: Test"
+    - cmd: echo "Step 3: Build"
+"#;
+
+    fs::write(path, starter).context("Failed to create rnr.yaml")?;
+    println!("  Created {}", CONFIG_FILE);
+
+    Ok(())
+}

src/commands/list.rs

@@ -0,0 +1,39 @@
+use anyhow::Result;
+
+use crate::config::{Config, TaskDef};
+
+/// Run the list command
+pub fn run() -> Result<()> {
+    let config = Config::load()?;
+
+    println!("\nAvailable tasks:\n");
+
+    let task_names = config.task_names();
+
+    if task_names.is_empty() {
+        println!("  No tasks defined in rnr.yaml");
+        return Ok(());
+    }
+
+    // Find the longest task name for alignment
+    let max_len = task_names.iter().map(|n| n.len()).max().unwrap_or(0);
+
+    for name in task_names {
+        let description = get_task_description(&config, name);
+        match description {
+            Some(desc) => println!("  {:<width$}  {}", name, desc, width = max_len),
+            None => println!("  {}", name),
+        }
+    }
+
+    println!();
+    Ok(())
+}
+
+/// Get the description for a task, if any
+fn get_task_description(config: &Config, name: &str) -> Option<String> {
+    match config.get_task(name)? {
+        TaskDef::Shorthand(_) => None,
+        TaskDef::Full(task) => task.description.clone(),
+    }
+}

src/commands/mod.rs

@@ -0,0 +1,3 @@
+pub mod init;
+pub mod list;
+pub mod upgrade;

src/commands/upgrade.rs

@@ -0,0 +1,67 @@
+use anyhow::{Context, Result};
+use std::path::PathBuf;
+
+/// Run the upgrade command
+pub fn run() -> Result<()> {
+    let rnr_dir = find_rnr_dir()?;
+    let bin_dir = rnr_dir.join("bin");
+
+    if !bin_dir.exists() {
+        anyhow::bail!("rnr is not initialized. Run 'rnr init' first.");
+    }
+
+    println!("Upgrading rnr binaries...");
+
+    #[cfg(feature = "network")]
+    {
+        upgrade_binaries(&bin_dir)?;
+    }
+
+    #[cfg(not(feature = "network"))]
+    {
+        println!("Network feature is disabled. Cannot download updates.");
+        println!("Please manually update binaries in .rnr/bin/");
+    }
+
+    Ok(())
+}
+
+/// Find the .rnr directory by walking up from current directory
+fn find_rnr_dir() -> Result<PathBuf> {
+    let current_dir = std::env::current_dir().context("Failed to get current directory")?;
+
+    let mut dir = current_dir.as_path();
+    loop {
+        let rnr_path = dir.join(".rnr");
+        if rnr_path.exists() && rnr_path.is_dir() {
+            return Ok(rnr_path);
+        }
+
+        match dir.parent() {
+            Some(parent) => dir = parent,
+            None => break,
+        }
+    }
+
+    anyhow::bail!("No .rnr directory found. Run 'rnr init' first.")
+}
+
+/// Download and replace binaries
+#[cfg(feature = "network")]
+fn upgrade_binaries(bin_dir: &std::path::Path) -> Result<()> {
+    // TODO: Implement actual binary downloads
+    // 1. Check current version
+    // 2. Check latest version from server
+    // 3. Download if newer version available
+    // 4. Replace binaries
+
+    println!("  Checking for updates...");
+    println!("    TODO: Check https://rnr.dev/bin/latest/");
+    println!("    TODO: Download updated binaries");
+    println!("\nUpgrade complete!");
+
+    // Placeholder for actual implementation
+    let _ = bin_dir;
+
+    Ok(())
+}