Add comprehensive tests for hooks functionality and update plan.md

- Introduced extensive test suite covering edge cases for all built-in hooks, ensuring thorough validation.
- Updated `plan.md` to streamline tasks by removing unnecessary hook expansion item for https://pre-commit.com/hooks.html.

Author: jensenbox

docs/node.md

@@ -0,0 +1,59 @@
+## 📦 Node.js Runtime Installer for Rustyhook CLI
+
+This document outlines what your agent should build: a **Node.js prebuilt binary installer** that can be integrated into the `rustyhook` CLI tool as part of its environment setup. It should be implemented in Rust, but **this is not code**, only functional specifications.
+
+---
+
+### 🧩 Purpose
+Create a utility that:
+- Downloads a precompiled Node.js binary (from nodejs.org)
+- Extracts it to a local subdirectory (e.g. `.runtime/node/{version}`)
+- Verifies the installation by running `node --version`
+- Is invoked by `rustyhook`'s setup/init code as a prerequisite step for environments that depend on Node
+
+---
+
+### 🎯 Functional Requirements
+
+This system must support all major platforms, including Windows. On Windows, `.zip` archives should be downloaded instead of `.tar.xz`, and executable paths should reflect `.exe` suffixes and native directory conventions. Paths should be normalized to ensure compatibility across OS boundaries.
+
+#### 1. **Target Node.js Versions**
+- Accept a specific Node.js version (e.g. `20.11.1`) passed from config or CLI flags
+- If not provided, determine the version from a standard dotfile such as `.node-version` or `.nvmrc` in the project root (e.g. `20.11.1`) passed from config or CLI flags
+
+#### 2. **Platform Detection**
+- Dynamically determine platform triple (`linux-x64`, `darwin-arm64`, `win-x64`, etc) using system information
+
+#### 3. **Download Prebuilt Binary**
+- Pull `.tar.xz` or `.zip` from `https://nodejs.org/dist/v{version}/node-v{version}-{platform}.tar.xz`
+- Save to a cache or local working directory
+
+#### 4. **Extraction**
+- Extract into `.runtime/node/{version}/`
+- Final path should include:
+    - Node binary at `.runtime/node/{version}/node-v{version}-{platform}/bin/node`
+    - Do not assume or require the presence of `npm` or `npx` binaries
+    - Systems depending on Node should function without relying on existing global tooling like `npm` or `npx``.runtime/node/{version}/`
+- Final path should include:
+    - Node binary at `.runtime/node/{version}/node-v{version}-{platform}/bin/node`
+    - Optionally, `npm`/`npx` if available
+
+#### 5. **Verification**
+- Run `node --version` from the installed path
+- Log or return the installed version string
+
+---
+
+### 🔗 Integration Expectations
+
+- This logic will not be standalone. It is invoked by `rustyhook` as part of its environment bootstrap.
+- Prefer returning `Result<PathBuf, Error>` from the installer interface so the caller can handle success/failure
+- No hardcoded version strings
+
+---
+
+### 💡 Optional Enhancements
+- Cache previously downloaded archives.
+- Support a `--force` option to reinstall even if a version is present
+
+

fnm_analysis.md

@@ -385,15 +385,47 @@ fn diagnose_issues() {
         },
     }
 
-    // Check if Node.js is installed
-    match which::which("node") {
+    // Check if fnm (Fast Node Manager) is installed
+    match which::which("fnm") {
         Ok(path) => {
-            info!("Node.js is installed at: {}", path.display());
-            debug!("Node.js found at path: {}", path.display());
+            info!("fnm is installed at: {}", path.display());
+            debug!("fnm found at path: {}", path.display());
+
+            // Check if Node.js is installed via fnm
+            let output = std::process::Command::new("fnm")
+                .arg("list")
+                .output();
+
+            match output {
+                Ok(output) if output.status.success() => {
+                    let versions = String::from_utf8_lossy(&output.stdout);
+                    if !versions.trim().is_empty() {
+                        info!("Node.js is installed via fnm. Available versions: {}", versions.trim());
+                    } else {
+                        warn!("No Node.js versions installed via fnm. Some hooks may not work.");
+                        debug!("fnm list returned empty result");
+                    }
+                },
+                _ => {
+                    warn!("Failed to check Node.js versions via fnm. Some hooks may not work.");
+                    debug!("Failed to execute fnm list");
+                }
+            }
         },
         Err(_) => {
-            warn!("Node.js is not installed. Some hooks may not work.");
-            debug!("Failed to find Node.js in PATH");
+            // If fnm is not installed, check for Node.js directly
+            match which::which("node") {
+                Ok(path) => {
+                    info!("Node.js is installed at: {}", path.display());
+                    debug!("Node.js found at path: {}", path.display());
+                    info!("Consider installing fnm for better Node.js version management.");
+                },
+                Err(_) => {
+                    warn!("Neither fnm nor Node.js is installed. Some hooks may not work.");
+                    debug!("Failed to find fnm or Node.js in PATH");
+                    info!("RustyHook will attempt to install fnm and Node.js when needed.");
+                },
+            }
         },
     }
 

src/lib.rs

@@ -1,12 +1,14 @@
 //! Node.js toolchain support for RustyHook
 //!
 //! This module provides functionality for managing Node.js environments and packages.
+//! It uses fnm (Fast Node Manager) to install and manage Node.js versions.
 
 use std::fs;
 use std::path::PathBuf;
 use std::process::Command;
 use which::which;
 use serde::{Serialize, Deserialize};
+use log::{debug, info, warn, error};
 
 use super::r#trait::{SetupContext, Tool, ToolError};
 
@@ -75,6 +77,114 @@ impl NodeTool {
         }
     }
 
+    /// Check if fnm is installed
+    fn is_fnm_installed(&self) -> bool {
+        which("fnm").is_ok()
+    }
+
+    /// Install fnm
+    fn install_fnm(&self) -> Result<(), ToolError> {
+        debug!("Installing fnm...");
+
+        // Create a temporary directory for the installation
+        let temp_dir = std::env::temp_dir().join("rustyhook_fnm_install");
+        std::fs::create_dir_all(&temp_dir)?;
+
+        // Download the fnm installation script
+        let curl_output = Command::new("curl")
+            .arg("-fsSL")
+            .arg("https://fnm.vercel.app/install")
+            .current_dir(&temp_dir)
+            .output()
+            .map_err(|e| ToolError::ExecutionError(format!("Failed to download fnm: {}", e)))?;
+
+        if !curl_output.status.success() {
+            let stderr = String::from_utf8_lossy(&curl_output.stderr);
+            return Err(ToolError::ExecutionError(format!("Failed to download fnm: {}", stderr)));
+        }
+
+        // Save the script to a file
+        let script_path = temp_dir.join("install.sh");
+        std::fs::write(&script_path, curl_output.stdout)?;
+
+        // Make the script executable
+        Command::new("chmod")
+            .arg("+x")
+            .arg(&script_path)
+            .status()
+            .map_err(|e| ToolError::ExecutionError(format!("Failed to make fnm install script executable: {}", e)))?;
+
+        // Run the installation script with --skip-shell to avoid modifying shell config
+        let install_output = Command::new("bash")
+            .arg(&script_path)
+            .arg("--skip-shell")
+            .current_dir(&temp_dir)
+            .output()
+            .map_err(|e| ToolError::ExecutionError(format!("Failed to install fnm: {}", e)))?;
+
+        if !install_output.status.success() {
+            let stderr = String::from_utf8_lossy(&install_output.stderr);
+            return Err(ToolError::ExecutionError(format!("Failed to install fnm: {}", stderr)));
+        }
+
+        info!("fnm installed successfully");
+        Ok(())
+    }
+
+    /// Ensure Node.js is installed using fnm
+    fn ensure_node_installed(&self, node_version: &str) -> Result<(), ToolError> {
+        debug!("Ensuring Node.js {} is installed...", node_version);
+
+        // Check if fnm is installed, install it if not
+        if !self.is_fnm_installed() {
+            info!("fnm not found, installing...");
+            self.install_fnm()?;
+        }
+
+        // Check if the specified Node.js version is installed
+        let list_output = Command::new("fnm")
+            .arg("list")
+            .output()
+            .map_err(|e| ToolError::ExecutionError(format!("Failed to list Node.js versions: {}", e)))?;
+
+        let list_output_str = String::from_utf8_lossy(&list_output.stdout);
+
+        // If the version is not installed, install it
+        if !list_output_str.contains(node_version) {
+            info!("Installing Node.js {}...", node_version);
+
+            let install_output = Command::new("fnm")
+                .arg("install")
+                .arg(node_version)
+                .output()
+                .map_err(|e| ToolError::ExecutionError(format!("Failed to install Node.js {}: {}", node_version, e)))?;
+
+            if !install_output.status.success() {
+                let stderr = String::from_utf8_lossy(&install_output.stderr);
+                return Err(ToolError::ExecutionError(format!("Failed to install Node.js {}: {}", node_version, stderr)));
+            }
+
+            info!("Node.js {} installed successfully", node_version);
+        } else {
+            debug!("Node.js {} is already installed", node_version);
+        }
+
+        // Use the specified Node.js version
+        let use_output = Command::new("fnm")
+            .arg("use")
+            .arg(node_version)
+            .output()
+            .map_err(|e| ToolError::ExecutionError(format!("Failed to use Node.js {}: {}", node_version, e)))?;
+
+        if !use_output.status.success() {
+            let stderr = String::from_utf8_lossy(&use_output.stderr);
+            return Err(ToolError::ExecutionError(format!("Failed to use Node.js {}: {}", node_version, stderr)));
+        }
+
+        debug!("Using Node.js {}", node_version);
+        Ok(())
+    }
+
     /// Find the package manager executable
     fn find_package_manager(&self) -> Result<PathBuf, ToolError> {
         which(&self.package_manager).map_err(|_| {
@@ -151,6 +261,11 @@ impl Tool for NodeTool {
         // Create the installation directory if it doesn't exist
         std::fs::create_dir_all(&ctx.install_dir)?;
 
+        // Ensure Node.js is installed using fnm
+        // Use LTS version if not specified
+        let node_version = ctx.version.as_deref().unwrap_or("lts");
+        self.ensure_node_installed(node_version)?;
+
         // Generate package.json
         self.generate_package_json(ctx)?;
 

src/toolchains/node.rs

@@ -0,0 +1,92 @@
+//! Tests for Node.js toolchain functionality
+
+use rustyhook::toolchains::{NodeTool, Tool, SetupContext};
+use std::path::PathBuf;
+
+#[test]
+fn test_node_tool_with_fnm() {
+    // Create a temporary directory for the test
+    let temp_dir = tempfile::tempdir().unwrap();
+    let cache_dir = temp_dir.path().join(".rustyhook").join("cache");
+
+    // Create a Node.js tool with a test package
+    let node_tool = NodeTool::new("eslint", "1.0.0", vec!["eslint".to_string()], true, None);
+
+    // Get the installation directory from the Node tool
+    let install_dir = node_tool.install_dir().clone();
+
+    // Create the cache directory
+    std::fs::create_dir_all(&cache_dir).unwrap();
+
+    // Create a setup context
+    let ctx = SetupContext {
+        cache_dir: cache_dir.clone(),
+        install_dir: install_dir.clone(),
+        force: false,
+        version: Some("lts".to_string()), // Use LTS version of Node.js
+    };
+
+    // Set up the Node tool (this will install fnm and use it to install Node.js LTS)
+    println!("Setting up Node tool with fnm...");
+    let result = node_tool.setup(&ctx);
+
+    // Check that the setup was successful
+    assert!(result.is_ok(), "Failed to set up Node tool: {:?}", result);
+
+    // Check the installation directory structure
+    println!("Installation directory: {:?}", install_dir);
+    if install_dir.exists() {
+        println!("Installation directory exists");
+
+        // List the contents of the installation directory
+        if let Ok(entries) = std::fs::read_dir(&install_dir) {
+            println!("Contents of installation directory:");
+            for entry in entries {
+                if let Ok(entry) = entry {
+                    println!("  {:?}", entry.path());
+                }
+            }
+        } else {
+            println!("Failed to read installation directory");
+        }
+
+        // Check node_modules/.bin directory
+        let bin_dir = install_dir.join("node_modules").join(".bin");
+
+        if bin_dir.exists() {
+            println!("Bin directory exists: {:?}", bin_dir);
+
+            // List the contents of the bin directory
+            if let Ok(entries) = std::fs::read_dir(&bin_dir) {
+                println!("Contents of bin directory:");
+                for entry in entries {
+                    if let Ok(entry) = entry {
+                        println!("  {:?}", entry.path());
+                    }
+                }
+            } else {
+                println!("Failed to read bin directory");
+            }
+        } else {
+            println!("Bin directory does not exist: {:?}", bin_dir);
+        }
+    } else {
+        println!("Installation directory does not exist");
+    }
+
+    // Check that the Node tool is installed
+    println!("Checking if Node tool is installed...");
+    let is_installed = node_tool.is_installed();
+    println!("Node tool is installed: {}", is_installed);
+
+    // Get the tool path that is being checked
+    let tool_path = install_dir.join("node_modules").join(".bin").join("eslint");
+    println!("Tool path being checked: {:?}", tool_path);
+    println!("Tool path exists: {}", tool_path.exists());
+
+    // Assert that the Node tool is installed
+    assert!(is_installed, "Node tool is not installed");
+
+    // Assert that the eslint package is installed
+    assert!(tool_path.exists(), "eslint package is not installed");
+}

tests/node_toolchain_tests.rs

@@ -1,6 +1,6 @@
 //! Tests for toolchain functionality
 
-use rustyhook::toolchains::{PythonTool, Tool, SetupContext};
+use rustyhook::toolchains::{PythonTool, NodeTool, Tool, SetupContext};
 use std::path::PathBuf;
 
 #[test]