Add update command and relative env file paths

The changes include: - Adding new update command to download/install
latest version - Supporting relative env file paths based on taskfile
location - Modifying env parser to handle base paths for env files

Author: lassejlv

Cargo.lock

@@ -3,7 +3,7 @@ members = [".", "crates/env-parser", "crates/taskfile-runner"]
 
 [package]
 name = "taskfile"
-version = "0.2.0"
+version = "0.3.0"
 edition = "2024"
 
 [[bin]]

Cargo.toml

@@ -26,14 +26,28 @@ impl EnvParser {
     }
 
     pub fn load_env_files(&self) -> Result<(), Box<dyn std::error::Error>> {
+        self.load_env_files_with_base_path(None)
+    }
+
+    pub fn load_env_files_with_base_path(
+        &self,
+        base_path: Option<&std::path::Path>,
+    ) -> Result<(), Box<dyn std::error::Error>> {
         if let Some(env_config) = &self.config {
             for file_path in &env_config.files {
-                if std::path::Path::new(file_path).exists() {
-                    match self.load_env_file(file_path) {
+                let full_path = if let Some(base) = base_path {
+                    base.join(file_path)
+                } else {
+                    std::path::PathBuf::from(file_path)
+                };
+
+                if full_path.exists() {
+                    let path_str = full_path.to_string_lossy();
+                    match self.load_env_file(&path_str) {
                         Ok(count) => {
-                            println!("Loaded {} environment variables from: {}", count, file_path)
+                            println!("Loaded {} environment variables from: {}", count, path_str)
                         }
-                        Err(e) => eprintln!("Warning: Failed to load {}: {}", file_path, e),
+                        Err(e) => eprintln!("Warning: Failed to load {}: {}", path_str, e),
                     }
                 }
             }

crates/env-parser/src/lib.rs

@@ -31,7 +31,8 @@ impl TaskRunner {
 
         let env_parser = if let Some(env_config) = &taskfile.env {
             let parser = EnvParser::with_config(env_config.clone());
-            parser.load_env_files()?;
+            let taskfile_dir = std::path::Path::new(taskfile_path).parent();
+            parser.load_env_files_with_base_path(taskfile_dir)?;
             parser
         } else {
             EnvParser::new()
@@ -44,9 +45,13 @@ impl TaskRunner {
     }
 
     pub fn new(taskfile: TaskFile) -> Self {
+        Self::new_with_base_path(taskfile, None)
+    }
+
+    pub fn new_with_base_path(taskfile: TaskFile, base_path: Option<&std::path::Path>) -> Self {
         let env_parser = if let Some(env_config) = &taskfile.env {
             let parser = EnvParser::with_config(env_config.clone());
-            if let Err(e) = parser.load_env_files() {
+            if let Err(e) = parser.load_env_files_with_base_path(base_path) {
                 eprintln!("{} Error loading environment files: {}", "✗".red(), e);
             }
             parser

crates/taskfile-runner/src/lib.rs

@@ -9,7 +9,7 @@ async fn main() {
         .about("A simple task runner")
         .arg(
             Arg::new("command")
-                .help("The command to run (list, version, or task name)")
+                .help("The command to run (list, version, update, or task name)")
                 .value_name("COMMAND")
                 .index(1),
         )
@@ -27,6 +27,16 @@ async fn main() {
                     println!("taskfile-runner v{}", env!("CARGO_PKG_VERSION"));
                     println!("A simple task runner written in Rust");
                 }
+                Some(cmd) if cmd == "update" => {
+                    println!("Updating task runner...");
+                    match update_task_runner().await {
+                        Ok(_) => println!("✓ Update completed successfully!"),
+                        Err(e) => {
+                            eprintln!("{} Update failed: {}", "✗".red(), e);
+                            std::process::exit(1);
+                        }
+                    }
+                }
                 Some(task_name) => {
                     if let Err(e) = runner.run_task(task_name).await {
                         eprintln!("{} Error running task '{}': {}", "✗".red(), task_name, e);
@@ -35,7 +45,7 @@ async fn main() {
                 }
                 None => {
                     println!("Please specify a task to run or use 'list' to see available tasks.");
-                    println!("Usage: task <task_name> | list | version");
+                    println!("Usage: task <task_name> | list | version | update");
                     std::process::exit(1);
                 }
             },
@@ -54,3 +64,52 @@ async fn main() {
         }
     }
 }
+
+async fn update_task_runner() -> Result<(), Box<dyn std::error::Error>> {
+    use std::env;
+    use std::process::Stdio;
+    use tokio::process::Command;
+
+    let current_exe = env::current_exe()?;
+    let install_dir = current_exe.parent().unwrap();
+
+    println!("Downloading latest version...");
+
+    let output = Command::new("curl")
+        .args(&[
+            "-sSL",
+            "https://raw.githubusercontent.com/lassejlv/taskfile/main/install.sh",
+        ])
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .output()
+        .await?;
+
+    if !output.status.success() {
+        return Err("Failed to download install script".into());
+    }
+
+    let install_script = String::from_utf8(output.stdout)?;
+
+    let output = Command::new("bash")
+        .arg("-c")
+        .arg(&format!(
+            "echo '{}' | bash -s -- --install-dir '{}'",
+            install_script.replace("'", "'\"'\"'"),
+            install_dir.display()
+        ))
+        .stdout(Stdio::piped())
+        .stderr(Stdio::piped())
+        .output()
+        .await?;
+
+    if output.status.success() {
+        println!("Installation output:");
+        print!("{}", String::from_utf8_lossy(&output.stdout));
+        Ok(())
+    } else {
+        eprintln!("Error output:");
+        eprint!("{}", String::from_utf8_lossy(&output.stderr));
+        Err("Update installation failed".into())
+    }
+}