feat: add support for watcher to tests

Author: captainsafia

AGENTS.md

@@ -92,6 +92,7 @@ hone/
 - Prefer `&str` over `String` for function parameters when ownership isn't needed
 - Use `Option` and `Result` idiomatically; avoid sentinel values
 - Prefer explicit error types over `unwrap` / `expect` patterns
+- Use `.to_string_lossy().into_owned()` instead of `.to_string_lossy().to_string()` for converting to owned string values
 
 ### Source Control Conventions
 

Cargo.lock

@@ -31,6 +31,8 @@ dirs = "5"
 toml_edit = "0.22"
 relnotify = "1"
 reqwest = { version = "0.12", default-features = false, features = ["blocking", "rustls-tls", "native-tls-vendored"] }
+notify = "8"
+notify-debouncer-full = "0.6"
 
 [dev-dependencies]
 assert_matches = "1"

Cargo.toml

@@ -2,7 +2,9 @@ pub mod assertions;
 pub mod lsp;
 pub mod parser;
 pub mod runner;
+pub mod watcher;
 
 pub use lsp::run_lsp_server;
 pub use parser::{parse_file, HoneFile, ParseResult};
 pub use runner::{run_tests, OutputFormat, RunnerOptions, TestRunOutput};
+pub use watcher::run_watch_mode;

src/lib.rs

@@ -1,5 +1,5 @@
 use clap::{Parser, Subcommand};
-use hone::{run_lsp_server, run_tests, OutputFormat, RunnerOptions};
+use hone::{run_lsp_server, run_tests, run_watch_mode, OutputFormat, RunnerOptions};
 
 mod setup;
 mod update;
@@ -31,6 +31,10 @@ struct Cli {
     /// Output format
     #[arg(long = "output-format", value_enum, default_value = "text")]
     output_format: OutputFormat,
+
+    /// Watch mode: re-run tests when files change
+    #[arg(long, short)]
+    watch: bool,
 }
 
 #[derive(Subcommand)]
@@ -55,6 +59,10 @@ enum Commands {
         /// Output format
         #[arg(long = "output-format", value_enum, default_value = "text")]
         output_format: OutputFormat,
+
+        /// Watch mode: re-run tests when files change
+        #[arg(long, short)]
+        watch: bool,
     },
     /// Start the Language Server Protocol (LSP) server
     Lsp,
@@ -125,16 +133,22 @@ async fn main() -> anyhow::Result<()> {
             verbose,
             test_filter,
             output_format,
+            watch,
         }) => {
             let options = RunnerOptions {
                 shell,
                 verbose,
                 test_filter,
                 output_format,
             };
-            let results = run_tests(patterns, options).await?;
-            update::show_update_notification_if_available();
-            std::process::exit(if results.has_failures() { 1 } else { 0 });
+            if watch {
+                run_watch_mode(patterns, options).await?;
+                Ok(())
+            } else {
+                let results = run_tests(patterns, options).await?;
+                update::show_update_notification_if_available();
+                std::process::exit(if results.has_failures() { 1 } else { 0 });
+            }
         }
         None => {
             let options = RunnerOptions {
@@ -143,9 +157,14 @@ async fn main() -> anyhow::Result<()> {
                 test_filter: cli.test_filter,
                 output_format: cli.output_format,
             };
-            let results = run_tests(cli.patterns, options).await?;
-            update::show_update_notification_if_available();
-            std::process::exit(if results.has_failures() { 1 } else { 0 });
+            if cli.watch {
+                run_watch_mode(cli.patterns, options).await?;
+                Ok(())
+            } else {
+                let results = run_tests(cli.patterns, options).await?;
+                update::show_update_notification_if_available();
+                std::process::exit(if results.has_failures() { 1 } else { 0 });
+            }
         }
     }
 }

src/main.rs

@@ -14,8 +14,8 @@ use crate::runner::reporter::{
 };
 use crate::runner::shell::{create_shell_config, RunResult, ShellSession};
 use regex::Regex;
-use std::collections::{BTreeSet, HashMap};
-use std::path::{Path, PathBuf};
+use std::collections::HashMap;
+use std::path::Path;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 #[derive(Debug, Clone, Default)]
@@ -79,7 +79,6 @@ pub async fn run_tests(
 ) -> anyhow::Result<TestRunOutput> {
     let is_json = options.output_format == OutputFormat::Json;
     let reporter = DefaultReporter::new(options.verbose, options.output_format);
-    let cwd = std::env::current_dir()?.to_string_lossy().to_string();
     let start_time = std::time::Instant::now();
     let start_epoch = SystemTime::now()
         .duration_since(UNIX_EPOCH)
@@ -98,12 +97,7 @@ pub async fn run_tests(
         None
     };
 
-    let mut all_files = BTreeSet::new();
-    for pattern in &patterns {
-        let files = resolve_files(pattern, &cwd).await?;
-        all_files.extend(files);
-    }
-    let all_files: Vec<_> = all_files.into_iter().collect();
+    let all_files = crate::runner::resolve_patterns(&patterns).await?;
 
     if all_files.is_empty() {
         if !is_json {
@@ -265,47 +259,6 @@ pub async fn run_tests(
     Ok(output)
 }
 
-async fn resolve_files(pattern: &str, cwd: &str) -> anyhow::Result<Vec<String>> {
-    let resolved = PathBuf::from(cwd).join(pattern);
-
-    // Check if it's a direct file
-    if let Ok(metadata) = tokio::fs::metadata(&resolved).await {
-        if metadata.is_file() && pattern.ends_with(".hone") {
-            return Ok(vec![resolved.to_string_lossy().to_string()]);
-        }
-
-        if metadata.is_dir() {
-            // Use glob to find all .hone files in the directory
-            let pattern = format!("{}/**/*.hone", resolved.to_string_lossy());
-            let paths = glob::glob(&pattern)?;
-            let results: Vec<String> = paths
-                .filter_map(Result::ok)
-                .filter(|p| p.is_file())
-                .map(|p| p.to_string_lossy().to_string())
-                .collect();
-            return Ok(results);
-        }
-    }
-
-    // Use glob for pattern matching
-    let glob_pattern = if Path::new(pattern).is_absolute() {
-        pattern.to_string()
-    } else {
-        PathBuf::from(cwd)
-            .join(pattern)
-            .to_string_lossy()
-            .to_string()
-    };
-
-    let paths = glob::glob(&glob_pattern)?;
-    let results: Vec<String> = paths
-        .filter_map(Result::ok)
-        .filter(|p| p.is_file())
-        .map(|p| p.to_string_lossy().to_string())
-        .collect();
-    Ok(results)
-}
-
 async fn run_file(
     ast: &[ASTNode],
     filename: &str,