@repokit/core 1.3.5 → 1.3.7

package/Cargo.lock

@@ -3,40 +3,37 @@
 version = 4
 
 [[package]]
-name = "alphanumeric-sort"
-version = "1.5.5"
+name = "aho-corasick"
+version = "1.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "774ffdfeac16e9b4d75e41225dc2545d9c2082a0634b5d7f6f70e168546eecb1"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
 
 [[package]]
-name = "colored"
-version = "3.1.1"
+name = "alphanumeric-sort"
+version = "1.5.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34"
-dependencies = [
- "windows-sys",
-]
+checksum = "774ffdfeac16e9b4d75e41225dc2545d9c2082a0634b5d7f6f70e168546eecb1"
 
 [[package]]
-name = "crossbeam"
-version = "0.8.4"
+name = "bstr"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1137cd7e7fc0fb5d3c5a8678be38ec56e819125d8d7907411fe24ccb943faca8"
+checksum = "63044e1ae8e69f3b5a92c736ca6269b8d12fa7efe39bf34ddb06d102cf0e2cab"
 dependencies = [
- "crossbeam-channel",
- "crossbeam-deque",
- "crossbeam-epoch",
- "crossbeam-queue",
- "crossbeam-utils",
+ "memchr",
+ "serde",
 ]
 
 [[package]]
-name = "crossbeam-channel"
-version = "0.5.15"
+name = "colored"
+version = "3.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+checksum = "faf9468729b8cbcea668e36183cb69d317348c2e08e994829fb56ebfdfbaac34"
 dependencies = [
- "crossbeam-utils",
+ "windows-sys",
 ]
 
 [[package]]
@@ -58,27 +55,12 @@ dependencies = [
  "crossbeam-utils",
 ]
 
-[[package]]
-name = "crossbeam-queue"
-version = "0.3.12"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f58bbc28f91df819d0aa2a2c00cd19754769c2fad90579b3592b1c9ba7a3115"
-dependencies = [
- "crossbeam-utils",
-]
-
 [[package]]
 name = "crossbeam-utils"
 version = "0.8.21"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
 
-[[package]]
-name = "either"
-version = "1.15.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
-
 [[package]]
 name = "futures"
 version = "0.3.31"
@@ -169,27 +151,52 @@ dependencies = [
 ]
 
 [[package]]
-name = "itoa"
-version = "1.0.17"
+name = "globset"
+version = "0.4.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+checksum = "52dfc19153a48bde0cbd630453615c8151bce3a5adfac7a0aebfbf0a1e1f57e3"
+dependencies = [
+ "aho-corasick",
+ "bstr",
+ "log",
+ "regex-automata",
+ "regex-syntax",
+]
 
 [[package]]
-name = "jwalk"
-version = "0.8.1"
+name = "ignore"
+version = "0.4.25"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2735847566356cd2179a2a38264839308f7079fa96e6bd5a42d740460e003c56"
+checksum = "d3d782a365a015e0f5c04902246139249abf769125006fbe7649e2ee88169b4a"
 dependencies = [
- "crossbeam",
- "rayon",
+ "crossbeam-deque",
+ "globset",
+ "log",
+ "memchr",
+ "regex-automata",
+ "same-file",
+ "walkdir",
+ "winapi-util",
 ]
 
+[[package]]
+name = "itoa"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92ecc6618181def0457392ccd0ee51198e065e016d1d527a7ac1b6dc7c1f09d2"
+
 [[package]]
 name = "lexopt"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9fa0e2a1fcbe2f6be6c42e342259976206b383122fc152e872795338b5a3f3a7"
 
+[[package]]
+name = "log"
+version = "0.4.29"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e5032e24019045c762d3c0f28f5b6b8bbf38563a65908389bf7978758920897"
+
 [[package]]
 name = "memchr"
 version = "2.7.6"
@@ -233,25 +240,34 @@ dependencies = [
 ]
 
 [[package]]
-name = "rayon"
-version = "1.11.0"
+name = "regex"
+version = "1.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "368f01d005bf8fd9b1206fb6fa653e6c4a81ceb1466406b81792d87c5677a58f"
+checksum = "e10754a14b9137dd7b1e3e5b0493cc9171fdd105e0ab477f51b72e7f3ac0e276"
 dependencies = [
- "either",
- "rayon-core",
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
 ]
 
 [[package]]
-name = "rayon-core"
-version = "1.13.0"
+name = "regex-automata"
+version = "0.4.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22e18b0f0062d30d4230b2e85ff77fdfe4326feb054b9783a3460d8435c8ab91"
+checksum = "6e1dd4122fc1595e8162618945476892eefca7b88c52820e74af6262213cae8f"
 dependencies = [
- "crossbeam-deque",
- "crossbeam-utils",
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
 ]
 
+[[package]]
+name = "regex-syntax"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
+
 [[package]]
 name = "repokit"
 version = "0.1.0"
@@ -259,13 +275,22 @@ dependencies = [
  "alphanumeric-sort",
  "colored",
  "futures",
- "jwalk",
+ "ignore",
  "lexopt",
  "normalize-path",
+ "regex",
  "serde",
  "serde_json",
  "tokio",
- "tokio-thread-pool",
+]
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
 ]
 
 [[package]]
@@ -338,19 +363,29 @@ dependencies = [
 ]
 
 [[package]]
-name = "tokio-thread-pool"
-version = "1.0.0"
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d94c3392b98a14acc18fa639cb48e94355ed7aaae4a45164e394d6c4da39c9ec"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
 dependencies = [
- "tokio",
+ "same-file",
+ "winapi-util",
 ]
 
 [[package]]
-name = "unicode-ident"
-version = "1.0.22"
+name = "winapi-util"
+version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys",
+]
 
 [[package]]
 name = "windows-link"

package/Cargo.toml

@@ -14,9 +14,9 @@ colored = "3"
 lexopt = "0.3.1"
 normalize-path = "0.2.1"
 futures = "0.3.31"
-jwalk = "0.8.1"
 alphanumeric-sort = "1.5.5"
-tokio-thread-pool = "1.0.0"
 tokio = "1.49.0"
+ignore = "0.4.25"
+regex = { version = "1.12.3", features = ["std", "unicode"] }
 
 

package/internals/configuration/configuration.rs

@@ -1,23 +1,24 @@
-use std::{fs::File, io, path::Path, process::exit};
+use std::{path::Path, process::exit};
 
-use crate::{internal_filesystem::internal_filesystem::InternalFileSystem, logger::logger::Logger};
+use crate::{
+    internal_filesystem::{file_builder::FileBuilder, internal_filesystem::InternalFileSystem},
+    logger::logger::Logger,
+};
 
 pub struct Configuration;
 
 impl Configuration {
     pub fn create(root: &str) {
         let file_path = format!("{root}/repokit.ts");
-        let path_buf = Path::new(&file_path);
-        if path_buf.exists() {
+        let path = Path::new(&file_path);
+        if path.exists() {
             return;
         }
         Configuration::welcome();
-        let template_path =
+        let mut source =
             InternalFileSystem::new(root).resolve_template("configuration_template.ts");
-        let mut source = File::open(template_path).expect("Template");
-        let mut target = File::create(path_buf).expect("creating");
-        io::copy(&mut source, &mut target).expect("writing");
-        target.sync_all().expect("Flushing");
+        let mut target = FileBuilder::create(path, |_| Logger::file_create_error());
+        FileBuilder::copy_to(&mut source, &mut target, |_| Logger::file_write_error());
         Logger::info(
             format!(
                 "Please fill out this file with your desired settings. Then run {}",

package/internals/file_walker/mod.rs

@@ -0,0 +1 @@
+pub mod walker;

package/internals/file_walker/walker.rs

@@ -0,0 +1,83 @@
+use std::{
+    fs::File,
+    io::{BufRead, BufReader},
+    sync::{Arc, Mutex},
+};
+
+use ignore::{DirEntry, Error, ParallelVisitor, ParallelVisitorBuilder, WalkState};
+use regex::Regex;
+
+use crate::{internal_filesystem::file_builder::FileBuilder, logger::logger::Logger};
+
+pub struct TSFileVisitor {
+    root: String,
+    paths: Arc<Mutex<Vec<String>>>,
+}
+
+impl ParallelVisitor for TSFileVisitor {
+    fn visit(&mut self, entry: Result<DirEntry, Error>) -> WalkState {
+        let root_replacer = format!("{}/", self.root);
+        let repokit_import_matcher =
+            Regex::new(r#"(require\(|from[\s*]?)['"]@repokit/core["'][\)]?[;]?$"#).unwrap();
+        let template_matcher = Regex::new(r"externals\/templates\/[^\s]*?_template\.ts$").unwrap();
+        if let Ok(entry) = entry {
+            let path = entry.path();
+            let path_string = path.to_str().map_or("", |f| f);
+            if entry.file_type().is_some_and(|ft| ft.is_file())
+                && path_string.ends_with(".ts")
+                && !template_matcher.is_match(path_string)
+            {
+                let mut open_comment = false;
+                let file: File = FileBuilder::open(path_string, |_| Logger::open_file_error());
+                let reader: BufReader<File> = BufReader::new(file);
+                for line_result in reader.lines() {
+                    let unwrapped = line_result.unwrap();
+                    let line = unwrapped.trim();
+                    if !open_comment && line.starts_with("/**") {
+                        open_comment = true;
+                        continue;
+                    }
+                    if open_comment {
+                        if line == "*/" {
+                            open_comment = false;
+                        }
+                        continue;
+                    }
+                    if repokit_import_matcher.is_match(line) {
+                        let mut vector = self.paths.lock().unwrap();
+                        vector.push(path_string.to_string().replace(&root_replacer, ""));
+                        break;
+                    }
+                    if !line.is_empty()
+                        && !line.starts_with("import ")
+                        && !line.contains("require(")
+                        && !(line.starts_with("//") || line.starts_with("/*"))
+                    {
+                        break;
+                    }
+                }
+            }
+        }
+        WalkState::Continue
+    }
+}
+
+pub struct TSFileVisitorBuilder<'a> {
+    pub root: &'a str,
+    pub paths: &'a Arc<Mutex<Vec<String>>>,
+}
+
+impl<'a> TSFileVisitorBuilder<'a> {
+    pub fn new(root: &'a str, paths: &'a Arc<Mutex<Vec<String>>>) -> TSFileVisitorBuilder<'a> {
+        TSFileVisitorBuilder { paths, root }
+    }
+}
+
+impl<'s> ParallelVisitorBuilder<'s> for TSFileVisitorBuilder<'s> {
+    fn build(&mut self) -> Box<dyn ParallelVisitor + 's> {
+        Box::new(TSFileVisitor {
+            paths: self.paths.clone(),
+            root: self.root.to_string(),
+        })
+    }
+}

package/internals/internal_commands/help.rs

@@ -145,7 +145,14 @@ impl Help {
         sort_str_slice(&mut vector);
         vector
             .iter()
-            .map(|&name| RootCommand::from(name, commands.get(name).expect("known keys only")))
+            .map(|&name| {
+                RootCommand::from(
+                    name,
+                    commands
+                        .get(name)
+                        .expect("iteration is over known keys only"),
+                )
+            })
             .collect()
     }
 }

package/internals/internal_commands/register_command.rs

@@ -1,8 +1,6 @@
 use normalize_path::NormalizePath;
 use std::{
     collections::HashMap,
-    fs::{File, create_dir_all},
-    io,
     path::{Path, PathBuf},
     process,
 };
@@ -15,7 +13,7 @@ use crate::{
         },
     },
     internal_commands::help::Help,
-    internal_filesystem::internal_filesystem::InternalFileSystem,
+    internal_filesystem::{file_builder::FileBuilder, internal_filesystem::InternalFileSystem},
     logger::logger::Logger,
 };
 
@@ -56,7 +54,7 @@ impl RegisterCommand {
                 )
                 .as_str(),
             );
-            create_dir_all(&path).expect("");
+            FileBuilder::create_dir_all(&path, |_| Logger::file_directory_error());
         }
         if !path.is_dir() {
             RegisterCommand::exit_on_missing_path();
@@ -90,12 +88,10 @@ impl InternalExecutable for RegisterCommand {
     fn run(&self, args: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
         Logger::info("Registering a new command");
         let command_path = self.validate_path(args);
-        let template_path =
+        let mut source =
             InternalFileSystem::new(&self.scope.root).resolve_template("command_template.ts");
-        let mut source = File::open(template_path).expect("Template");
-        let mut target = File::create(&command_path).expect("creating");
-        io::copy(&mut source, &mut target).expect("writing");
-        target.sync_all().expect("Flushing");
+        let mut target = FileBuilder::create(&command_path, |_| Logger::file_create_error());
+        FileBuilder::copy_to(&mut source, &mut target, |_| Logger::file_write_error());
         Logger::info("Creating command file");
         Logger::info("Please fill out your command file located at:");
         Logger::log_file_path(command_path.to_str().expect("path"));

package/internals/internal_commands/typescript_command.rs

@@ -1,4 +1,4 @@
-use std::path::Path;
+use std::{path::Path, process::exit, sync::MutexGuard};
 
 use serde_json::from_str;
 
@@ -6,6 +6,7 @@ use crate::{
     configuration::configuration::Configuration,
     executor::executor::Executor,
     internal_filesystem::internal_filesystem::InternalFileSystem,
+    logger::logger::Logger,
     repokit::interfaces::{RepoKitCommand, RepoKitConfig},
 };
 
@@ -31,13 +32,23 @@ impl TypescriptCommand {
         config
     }
 
-    pub fn parse_commands(&self, path_list: Vec<String>) -> Vec<RepoKitCommand> {
+    pub fn parse_commands(&self, path_list: &MutexGuard<Vec<String>>) -> Vec<RepoKitCommand> {
         let paths = path_list.join(",");
         let executable = InternalFileSystem::new(&self.root).resolve_command("parse_commands.ts");
         let stdout =
             self.execute(format!("{executable} --paths {paths} --root {}", self.root).as_str());
-        let commands: Vec<RepoKitCommand> = serde_json::from_str(&stdout).expect("parse");
-        commands
+        let result: Result<Vec<RepoKitCommand>, serde_json::Error> = serde_json::from_str(&stdout);
+        match result {
+            Ok(commands) => commands,
+            Err(_) => {
+                Logger::info("There was an error parsing one of your commands");
+                Logger::info(
+                    "You can validate a command file's syntactical correctness by running",
+                );
+                Logger::log_file_path("tsc --noEmit");
+                exit(0);
+            }
+        }
     }
 
     fn execute(&self, args: &str) -> String {

package/internals/internal_filesystem/file_builder.rs

@@ -0,0 +1,57 @@
+use std::{
+    fs::{File, create_dir_all},
+    io::{Error, copy},
+    path::Path,
+    process::exit,
+};
+
+pub struct FileBuilder;
+
+impl FileBuilder {
+    pub fn open(source: &str, on_error: impl Fn(Error)) -> File {
+        let source = File::open(source);
+        match source {
+            Ok(file) => file,
+            Err(error) => {
+                on_error(error);
+                exit(0);
+            }
+        }
+    }
+
+    pub fn create(destination: &Path, on_error: impl Fn(Error)) -> File {
+        let source = File::create(destination);
+        match source {
+            Ok(file) => file,
+            Err(error) => {
+                on_error(error);
+                exit(0);
+            }
+        }
+    }
+
+    pub fn copy_to(source: &mut File, target: &mut File, on_error: impl Fn(Error)) {
+        let result = copy(source, target);
+        match result {
+            Ok(_) => {
+                let sync = target.sync_all();
+                match sync {
+                    Ok(_) => {}
+                    Err(err) => on_error(err),
+                }
+            }
+            Err(err) => on_error(err),
+        }
+    }
+
+    pub fn create_dir_all(path: &Path, on_error: impl Fn(Error)) {
+        let source = create_dir_all(path);
+        match source {
+            Ok(result) => result,
+            Err(error) => {
+                on_error(error);
+                exit(0);
+            }
+        }
+    }
+}

package/internals/internal_filesystem/internal_filesystem.rs

@@ -1,7 +1,13 @@
 use normalize_path::NormalizePath;
-use std::path::{Path, PathBuf};
+use std::{
+    fs::File,
+    path::{Path, PathBuf},
+};
 
-use crate::{executor::executor::Executor, logger::logger::Logger};
+use crate::{
+    executor::executor::Executor, internal_filesystem::file_builder::FileBuilder,
+    logger::logger::Logger,
+};
 
 pub struct InternalFileSystem {
     root: String,
@@ -23,8 +29,13 @@ impl InternalFileSystem {
         self.path_buf_to_str(self.commands_directory().join(file_name))
     }
 
-    pub fn resolve_template(&self, file_name: &str) -> String {
-        self.path_buf_to_str(self.templates_directory().join(file_name))
+    pub fn resolve_template(&self, file_name: &str) -> File {
+        let path = self.path_buf_to_str(self.templates_directory().join(file_name));
+        FileBuilder::open(&path, |_| {
+            Logger::error(format!("Unable to locate internal {file_name}").as_str());
+            Logger::error("Please file a bug here");
+            Logger::log_issue_link();
+        })
     }
 
     pub fn find_root() -> String {

package/internals/internal_filesystem/mod.rs

@@ -1 +1,2 @@
+pub mod file_builder;
 pub mod internal_filesystem;

package/internals/logger/logger.rs

@@ -1,5 +1,6 @@
+use std::process::exit;
+use std::sync::LazyLock;
 use std::sync::Mutex;
-use std::{process, sync::LazyLock};
 
 use colored::{ColoredString, Colorize, CustomColor};
 
@@ -23,12 +24,12 @@ impl Logger {
 
     pub fn exit_with_info(message: &str) {
         Logger::info(message);
-        process::exit(0);
+        exit(0);
     }
 
     pub fn exit_with_error(message: &str) {
         Logger::error(message);
-        process::exit(0);
+        exit(0);
     }
 
     pub fn space_around(message: &str) {
@@ -92,6 +93,33 @@ impl Logger {
         })
     }
 
+    pub fn file_create_error() {
+        Logger::file_error("create a file");
+    }
+
+    pub fn file_directory_error() {
+        Logger::file_error("create a directory");
+    }
+
+    pub fn open_file_error() {
+        Logger::file_error("read a file");
+    }
+
+    pub fn file_write_error() {
+        Logger::file_error("write to a file");
+    }
+
+    pub fn log_issue_link() {
+        Logger::log_file_path("https://github.com/alexfigliolia/repokit/issues");
+    }
+
+    fn file_error(operation: &str) {
+        Logger::info(format!("I was unable to {operation} in your repository").as_str());
+        Logger::error("Please verify the permissions on your working directory or file a bug here");
+        Logger::log_issue_link();
+        exit(0);
+    }
+
     fn info_prefix() -> ColoredString {
         format!("{}: ", *REGISTERED_NAME.lock().unwrap())
             .bright_magenta()

package/internals/main.rs

@@ -6,7 +6,7 @@ use crate::{
 mod configuration;
 mod executables;
 mod executor;
-mod external_commands;
+mod file_walker;
 mod internal_commands;
 mod internal_filesystem;
 mod logger;

package/internals/repokit/repokit.rs

@@ -36,7 +36,7 @@ impl RepoKit {
         let validator = CommandValidations::from(self);
         let internals = validator.collect_and_validate_internals();
         if internals.contains_key(&command) {
-            let interface = internals.get(&command).expect("exists");
+            let interface = internals.get(&command).expect("Unknown command");
             return interface.run(args, &internals);
         }
         if self.scope.configuration.commands.contains_key(&command) {
@@ -45,7 +45,7 @@ impl RepoKit {
                 .configuration
                 .commands
                 .get(&command)
-                .expect("exists");
+                .expect("Unknown command");
             return Executor::with_stdio(
                 format!("{} {}", root_script.command, &args.join(" ")),
                 |cmd| cmd.current_dir(Path::new(&self.scope.root)),
@@ -56,14 +56,16 @@ impl RepoKit {
             &internals, &externals,
         );
         if externals.contains_key(&command) {
-            let interface = externals.get(&command).expect("exists");
+            let interface = externals.get(&command).expect("Unknown command");
             if args.is_empty() {
                 return self.log_external_command(interface);
             }
             let sub_command = &args[0];
             if interface.commands.contains_key(sub_command) {
-                let script = interface.commands.get(sub_command).expect("exists");
-                let working_dir = Path::new(&interface.location).parent().expect("exists");
+                let script = interface.commands.get(sub_command).expect("Unknown script");
+                let working_dir = Path::new(&interface.location)
+                    .parent()
+                    .expect("Working directory not found");
                 return Executor::with_stdio(
                     format!("{} {}", &script.command, &args[1..].join(" ")),
                     |cmd| cmd.current_dir(working_dir),

package/internals/validations/command_validations.rs

@@ -1,13 +1,18 @@
-use std::collections::HashMap;
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex},
+};
 
-use futures::executor;
+use ignore::WalkBuilder;
 
 use crate::{
     executables::{
         intenal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
     },
-    external_commands::external_commands::ExternalCommands,
-    internal_commands::internal_registry::InternalRegistry,
+    file_walker::walker::TSFileVisitorBuilder,
+    internal_commands::{
+        internal_registry::InternalRegistry, typescript_command::TypescriptCommand,
+    },
     logger::logger::Logger,
     repokit::{interfaces::RepoKitCommand, repokit::RepoKit},
 };
@@ -36,8 +41,13 @@ impl CommandValidations {
     }
 
     pub fn collect_and_validate_externals(&self) -> HashMap<String, RepoKitCommand> {
-        let finder = ExternalCommands::new(&self.scope.root);
-        let externals = executor::block_on(finder.find_all());
+        let paths: Arc<Mutex<Vec<String>>> = Arc::new(Mutex::new(Vec::new()));
+        let mut visitor = TSFileVisitorBuilder::new(&self.scope.root, &paths);
+        WalkBuilder::new(&self.scope.root)
+            .build_parallel()
+            .visit(&mut visitor);
+        let result = paths.lock().unwrap();
+        let externals = TypescriptCommand::new(&self.scope.root).parse_commands(&result);
         let all = [&externals[..], &self.scope.configuration.thirdParty[..]].concat();
         self.detect_collisions_between_root_commands_and_externals(&all)
     }
@@ -88,7 +98,7 @@ impl CommandValidations {
         let mut map: HashMap<String, RepoKitCommand> = HashMap::new();
         for command in externals {
             if map.contains_key(&command.name) {
-                let original = map.get(&command.name).expect("existent key");
+                let original = map.get(&command.name).expect("Unknown command");
                 self.on_external_duplicate_collision(command, &original.location);
             }
             map.insert(command.name.clone(), command.clone());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",
@@ -37,9 +37,9 @@
   },
   "devDependencies": {
     "@types/node": "^25.2.1",
-    "oxfmt": "^0.27.0",
+    "oxfmt": "^0.33.0",
     "oxlint": "^1.42.0",
-    "oxlint-tsgolint": "^0.11.3",
+    "oxlint-tsgolint": "^0.14.0",
     "typescript": "^5.9.3"
   }
 }

package/internals/external_commands/external_commands.rs

@@ -1,135 +0,0 @@
-use std::{
-    fs::File,
-    io::{BufRead, BufReader},
-    path::Path,
-};
-
-use futures::{TryStreamExt, stream::FuturesUnordered};
-use jwalk::WalkDir;
-use tokio_thread_pool::ThreadPool;
-
-use crate::{
-    internal_commands::typescript_command::TypescriptCommand, repokit::interfaces::RepoKitCommand,
-};
-
-pub struct ExternalCommands {
-    pub root: String,
-}
-
-impl ExternalCommands {
-    pub fn new(root: &str) -> ExternalCommands {
-        ExternalCommands {
-            root: root.to_string(),
-        }
-    }
-
-    pub async fn find_all(&self) -> Vec<RepoKitCommand> {
-        let mut futures = FuturesUnordered::new();
-        let mut pool = ThreadPool::new(None, None, None);
-        for entry in WalkDir::new(&self.root).into_iter().filter_map(|e| {
-            if e.is_err() {
-                return None;
-            }
-            let option = e.ok();
-            match option {
-                Some(file) => {
-                    let path = file.path();
-                    if file.file_type().is_file()
-                        && path.extension().is_some_and(|ext| ext == "ts")
-                        && self.allowed(path.to_str().expect("exists"))
-                    {
-                        return Some(file);
-                    }
-                    None
-                }
-                None => None,
-            }
-        }) {
-            let path = entry.path();
-            futures.push(pool.spawn(move || {
-                if ExternalCommands::read(&path) {
-                    return Some(path.clone());
-                }
-                None
-            }));
-        }
-        let mut paths: Vec<String> = Vec::new();
-        while let Ok(Some(buffer)) = futures.try_next().await {
-            if let Some(path) = buffer {
-                paths.push(
-                    (path)
-                        .into_os_string()
-                        .into_string()
-                        .expect("stringify")
-                        .replace(&self.root, ""),
-                )
-            }
-        }
-        pool.pool.shutdown_background();
-        TypescriptCommand::new(&self.root).parse_commands(paths)
-    }
-
-    fn read(path: &Path) -> bool {
-        let file: File = File::open(path).expect("file");
-        let reader: BufReader<File> = BufReader::new(file);
-        for line_result in reader.lines() {
-            let line: String = line_result.expect("line");
-            if line.ends_with("\"@repokit/core\";") || line.ends_with("'@repokit/core';") {
-                return true;
-            }
-        }
-        false
-    }
-
-    fn allowed(&self, path: &str) -> bool {
-        let restricted_paths = ["node_modules", "target", "dist"];
-        let restricted_extensions = ["templates/command_template.ts"];
-        let relative_path = path.replace(format!("{}/", &self.root).as_str(), "");
-        if ExternalCommands::restrict(
-            &relative_path,
-            &restricted_paths,
-            RestrictDirection::Forwards,
-        ) {
-            return false;
-        }
-        if ExternalCommands::restrict(
-            &relative_path,
-            &restricted_extensions,
-            RestrictDirection::Backwards,
-        ) {
-            return false;
-        }
-        let components = relative_path.split('/');
-        for token in components {
-            for restricted_path in restricted_paths {
-                if token == restricted_path {
-                    return false;
-                }
-            }
-        }
-        true
-    }
-
-    fn restrict(path: &str, tokens: &[&str], direction: RestrictDirection) -> bool {
-        for restricted in tokens {
-            match direction {
-                RestrictDirection::Forwards => {
-                    if path.starts_with(restricted) {
-                        return true;
-                    }
-                }
-                RestrictDirection::Backwards => {
-                    if path.ends_with(restricted) {
-                        return true;
-                    }
-                }
-            }
-        }
-        false
-    }
-}
-
-enum RestrictDirection {
-    Forwards,
-    Backwards,
-}

package/internals/external_commands/mod.rs

@@ -1 +0,0 @@
-pub mod external_commands;