@repokit/core 4.0.4 → 4.0.5

package/Cargo.lock

@@ -121,6 +121,12 @@ version = "0.6.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "175812e0be2bccb6abe50bb8d566126198344f707e304f45c648fd8f2cc0365e"
 
+[[package]]
+name = "bytes"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e748733b7cbc798e1434b6ac524f0c1ff2ab456fe201501e6497c8417a4fc33"
+
 [[package]]
 name = "cfg-if"
 version = "1.0.4"
@@ -170,7 +176,7 @@ dependencies = [
  "bitflags 1.3.2",
  "crossterm_winapi",
  "libc",
- "mio",
+ "mio 0.7.14",
  "parking_lot 0.11.2",
  "signal-hook",
  "signal-hook-mio",
@@ -685,6 +691,17 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "mio"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "50b7e5b27aa02a74bac8c3f23f448f8d87ff11f92d3aac1a6ed369ee08cc56c1"
+dependencies = [
+ "libc",
+ "wasi",
+ "windows-sys",
+]
+
 [[package]]
 name = "miow"
 version = "0.3.7"
@@ -996,7 +1013,7 @@ checksum = "a96887878f22d7bad8a3b6dc5b7440e0ada9a245242924394987b21cf2210a4c"
 
 [[package]]
 name = "repokit"
-version = "4.0.4"
+version = "4.0.5"
 dependencies = [
  "alphanumeric-sort",
  "colored",
@@ -1010,6 +1027,7 @@ dependencies = [
  "serde_json",
  "shellexpand",
  "terminal-spinners",
+ "tokio",
 ]
 
 [[package]]
@@ -1138,7 +1156,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
 dependencies = [
  "libc",
- "mio",
+ "mio 0.7.14",
  "signal-hook",
 ]
 
@@ -1164,6 +1182,16 @@ version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
 
+[[package]]
+name = "socket2"
+version = "0.6.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a766e1110788c36f4fa1c2b71b387a7815aa65f88ce0229841826633d93723e"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -1275,6 +1303,34 @@ dependencies = [
  "zerovec",
 ]
 
+[[package]]
+name = "tokio"
+version = "1.52.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67dee974fe86fd92cc45b7a95fdd2f99a36a6d7b0d431a231178d3d670bbcc6"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio 1.2.0",
+ "parking_lot 0.12.5",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2",
+ "tokio-macros",
+ "windows-sys",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "385a6cb71ab9ab790c5fe8d67f1645e6c450a7ce006a33de03daa956cf70a496"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "unicode-general-category"
 version = "1.1.0"

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "repokit"
-version = "4.0.4"
+version = "4.0.5"
 edition = "2024"
 
 [[bin]]
@@ -20,3 +20,4 @@ shellexpand = "3.1.2"
 schemars = "1.2.1"
 terminal-spinners = "0.3.2"
 futures = "0.3.32"
+tokio = { version = "1.52.1", features = ["full"] }

package/dist/CommandParser.mjs

@@ -6,12 +6,11 @@ import { stat } from "node:fs/promises";
 import { existsSync } from "node:fs";
 //#region externals/CommandParser.ts
 var CommandParser = class extends TSCompiler {
-	static async parse() {
+	static parse = this.wrapParsingOperation(async () => {
 		const { paths, root } = this.parsePaths();
-		if (!root || !existsSync(root) || !(await stat(root)).isDirectory()) return console.log(JSON.stringify([]));
-		const commands = paths.split(",").filter(Boolean).map((path) => this.parseCommand(root, path));
-		console.log(JSON.stringify(commands.flat()));
-	}
+		if (!root || !existsSync(root) || !(await stat(root)).isDirectory()) return [];
+		return paths.split(",").filter(Boolean).map((path) => this.parseCommand(root, path)).flat();
+	});
 	static parseCommand(root, path) {
 		const commands = [];
 		const declaredExports = super.compile(join(root, path));

package/dist/ConfigurationParser.mjs

@@ -5,12 +5,12 @@ import { join } from "node:path";
 import { existsSync } from "node:fs";
 //#region externals/ConfigurationParser.ts
 var ConfigurationParser = class extends TSCompiler {
-	static parse() {
+	static parse = this.wrapParsingOperation(() => {
 		const path = join(this.parseRoot(), "repokit.ts");
 		if (!existsSync(path)) return;
 		const config = super.compile(path);
-		for (const key in config) if (config[key] instanceof RepoKitConfig) return console.log(JSON.stringify(config[key].toScoped(path)));
-	}
+		for (const key in config) if (config[key] instanceof RepoKitConfig) return config[key].toScoped(path);
+	});
 	static parseRoot() {
 		return parseArgs({ options: { root: {
 			default: "",

package/dist/TSCompiler.mjs

@@ -2,6 +2,7 @@ import { __require } from "./_virtual/_rolldown/runtime.mjs";
 import { register } from "ts-node";
 //#region externals/TSCompiler.ts
 var TSCompiler = class {
+	static PARSE_INDICATOR = "=============== REPOKIT PARSE FLAG ===============";
 	static compilerOptions = {
 		swc: true,
 		typeCheck: false,
@@ -14,11 +15,38 @@ var TSCompiler = class {
 		moduleTypes: { "**": "cjs" }
 	};
 	static compile(path) {
-		const compiler = register(this.compilerOptions);
-		compiler.enabled(true);
-		const result = __require(path);
-		compiler.enabled(false);
-		return result;
+		try {
+			const compiler = register(this.compilerOptions);
+			compiler.enabled(true);
+			const result = __require(path);
+			compiler.enabled(false);
+			return result;
+		} catch (error) {
+			console.error(`Failure to parse module at path ${path}`, error);
+			return {};
+		}
+	}
+	static wrapParsingOperation(operation) {
+		return (...params) => {
+			const restore = this.plugExits();
+			const result = operation(...params);
+			if (result instanceof Promise) return result.then((v) => this.toStdout(v, restore));
+			return this.toStdout(result, restore);
+		};
+	}
+	static toStdout(result, ...callbacks) {
+		if (typeof result !== "undefined") console.log(`${this.PARSE_INDICATOR}${JSON.stringify(result)}${this.PARSE_INDICATOR}`);
+		callbacks.forEach((c) => c());
+	}
+	static plugExits() {
+		const { exit, abort } = process;
+		process.abort = () => void 0;
+		process.exit = (_code) => void 0;
+		return () => {
+			process.exit = exit;
+			process.abort = abort;
+			process.exitCode = 0;
+		};
 	}
 };
 //#endregion

package/dist/index.d.mts

@@ -1,5 +1,5 @@
 import { RepoKitTheme } from "./RepoKitTheme.mjs";
 import { RepoKitConfig } from "./RepoKitConfig.mjs";
-import { AsyncTask, ICommand, ILocatedCommand, IRepoKitCommand, IRepoKitConfig, IRepoKitTheme, RGBString, RepoKitThemeColors } from "./types.mjs";
+import { AsyncTask, ICommand, ILocatedCommand, IRepoKitCommand, IRepoKitConfig, IRepoKitTheme, RGBString, RepoKitThemeColors, UnwrappedBrigdeOperation } from "./types.mjs";
 import { RepoKitCommand } from "./RepoKitCommand.mjs";
-export { AsyncTask, ICommand, ILocatedCommand, IRepoKitCommand, IRepoKitConfig, IRepoKitTheme, RGBString, RepoKitCommand, RepoKitConfig, RepoKitTheme, RepoKitThemeColors };
+export { AsyncTask, ICommand, ILocatedCommand, IRepoKitCommand, IRepoKitConfig, IRepoKitTheme, RGBString, RepoKitCommand, RepoKitConfig, RepoKitTheme, RepoKitThemeColors, UnwrappedBrigdeOperation };

package/dist/types.d.mts

@@ -34,5 +34,6 @@ interface IRepoKitTheme {
   name: string;
   colors: RepoKitThemeColors;
 }
+type UnwrappedBrigdeOperation<F extends (...args: unknown[]) => unknown, T = void> = ReturnType<F> extends Promise<unknown> ? Promise<T> : T;
 //#endregion
-export { AsyncTask, ICommand, ILocatedCommand, IRepoKitCommand, IRepoKitConfig, IRepoKitTheme, RGBString, RepoKitThemeColors };
+export { AsyncTask, ICommand, ILocatedCommand, IRepoKitCommand, IRepoKitConfig, IRepoKitTheme, RGBString, RepoKitThemeColors, UnwrappedBrigdeOperation };

package/externals/CommandParser.ts

@@ -6,24 +6,23 @@ import { existsSync } from "node:fs";
 import type { ILocatedCommand } from "./types";
 import { TSCompiler } from "./TSCompiler";
 import { RepoKitCommand } from "./RepoKitCommand";
-/* oxlint-disable typescript-eslint(no-misused-spread) */
 
 export class CommandParser extends TSCompiler {
-  public static async parse() {
+  public static readonly parse = this.wrapParsingOperation(async () => {
     const { paths, root } = this.parsePaths();
     if (!root || !existsSync(root) || !(await stat(root)).isDirectory()) {
-      return console.log(JSON.stringify([]));
+      return [];
     }
     const pathList = paths.split(",").filter(Boolean);
-    const commands = pathList.map(path => this.parseCommand(root, path));
-    console.log(JSON.stringify(commands.flat()));
-  }
+    return pathList.map(path => this.parseCommand(root, path)).flat();
+  });
 
   private static parseCommand(root: string, path: string) {
     const commands: ILocatedCommand[] = [];
     const declaredExports = super.compile(join(root, path));
     for (const key in declaredExports) {
       if (declaredExports[key] instanceof RepoKitCommand) {
+        // oxlint-disable-next-line typescript-eslint(no-misused-spread)
         commands.push({ ...declaredExports[key], location: path });
       }
     }

package/externals/ConfigurationParser.ts

@@ -6,19 +6,20 @@ import { TSCompiler } from "./TSCompiler";
 import { RepoKitConfig } from "./RepoKitConfig";
 
 export class ConfigurationParser extends TSCompiler {
-  public static parse() {
+  public static readonly parse = this.wrapParsingOperation(() => {
     const root = this.parseRoot();
     const path = join(root, "repokit.ts");
     if (!existsSync(path)) {
-      return;
+      return undefined;
     }
     const config = super.compile(path);
     for (const key in config) {
       if (config[key] instanceof RepoKitConfig) {
-        return console.log(JSON.stringify(config[key].toScoped(path)));
+        return config[key].toScoped(path);
       }
     }
-  }
+    return undefined;
+  });
 
   private static parseRoot() {
     return parseArgs({

package/externals/TSCompiler.ts

@@ -1,7 +1,11 @@
-import { register } from "ts-node";
 import type { RegisterOptions } from "ts-node";
+import { register } from "ts-node";
+
+import type { UnwrappedBrigdeOperation } from "./types";
 
 export class TSCompiler {
+  private static PARSE_INDICATOR =
+    "=============== REPOKIT PARSE FLAG ===============";
   private static readonly compilerOptions: RegisterOptions = {
     swc: true,
     typeCheck: false,
@@ -17,10 +21,51 @@ export class TSCompiler {
   };
 
   public static compile<T extends Record<string, unknown>>(path: string) {
-    const compiler = register(this.compilerOptions);
-    compiler.enabled(true);
-    const result = require(path) as T;
-    compiler.enabled(false);
-    return result;
+    try {
+      const compiler = register(this.compilerOptions);
+      compiler.enabled(true);
+      const result = require(path) as T;
+      compiler.enabled(false);
+      return result;
+    } catch (error) {
+      console.error(`Failure to parse module at path ${path}`, error);
+      return {} as T;
+    }
+  }
+
+  public static wrapParsingOperation<F extends (...args: unknown[]) => unknown>(
+    operation: F,
+  ) {
+    return (...params: Parameters<F>) => {
+      const restore = this.plugExits();
+      const result = operation(...params);
+      if (result instanceof Promise) {
+        return result.then(v =>
+          this.toStdout(v, restore),
+        ) as UnwrappedBrigdeOperation<F>;
+      }
+      return this.toStdout(result, restore) as UnwrappedBrigdeOperation<F>;
+    };
+  }
+
+  private static toStdout<T>(result: T, ...callbacks: (() => void)[]) {
+    if (typeof result !== "undefined") {
+      console.log(
+        `${this.PARSE_INDICATOR}${JSON.stringify(result)}${this.PARSE_INDICATOR}`,
+      );
+    }
+    callbacks.forEach(c => c());
+  }
+
+  private static plugExits() {
+    // oxlint-disable-next-line typescript-eslint(unbound-method)
+    const { exit, abort } = process;
+    process.abort = () => undefined as never;
+    process.exit = (_code?: string | number | null) => undefined as never;
+    return () => {
+      process.exit = exit;
+      process.abort = abort;
+      process.exitCode = 0;
+    };
   }
 }

package/externals/commands/parse_configuration.ts

@@ -1,5 +1,3 @@
 import { ConfigurationParser } from "../ConfigurationParser";
 
-(() => {
-  ConfigurationParser.parse();
-})();
+ConfigurationParser.parse();

package/externals/types.ts

@@ -45,3 +45,8 @@ export interface IRepoKitTheme {
   name: string;
   colors: RepoKitThemeColors;
 }
+
+export type UnwrappedBrigdeOperation<
+  F extends (...args: unknown[]) => unknown,
+  T = void,
+> = ReturnType<F> extends Promise<unknown> ? Promise<T> : T;

package/installation/install.sh

@@ -1,4 +1,4 @@
-CURRENT_VERSION="4.0.4"
+CURRENT_VERSION="4.0.5"
 CWD=$(pwd)
 
 REPLACEMENT="/node_modules"

package/internals/caches/crawl_cache.rs

@@ -13,12 +13,14 @@ use crate::{
 #[derive(Clone)]
 pub struct CrawlCache {
     pub cache_directory: Option<PathBuf>,
+    pub changed_files: Option<Vec<String>>,
     pub files_to_crawl: Option<Vec<String>>,
 }
 
 impl CrawlCache {
     pub fn new(cache_directory: &Option<PathBuf>) -> Self {
         CrawlCache {
+            changed_files: None,
             files_to_crawl: None,
             cache_directory: cache_directory.clone(),
         }
@@ -34,7 +36,7 @@ impl CrawlCache {
             if commit_hash != head_commit {
                 return;
             }
-            let mut lines = self.line_buffer_to_vec(lines);
+            let lines = self.line_buffer_to_vec(lines);
             if lines.is_empty() {
                 return;
             }
@@ -48,8 +50,8 @@ impl CrawlCache {
                     changed_files.remove(line);
                 }
             }
-            for line in changed_files {
-                lines.push(line);
+            if !changed_files.is_empty() {
+                self.changed_files = Some(changed_files.into_iter().collect());
             }
             self.files_to_crawl = Some(lines);
         }

package/internals/context/typescript_bridge.rs

@@ -1,20 +1,26 @@
 use core::panic;
 use std::{
     path::{Path, PathBuf},
-    sync::MutexGuard,
+    sync::{LazyLock, MutexGuard},
 };
 
+use regex::Regex;
 use serde_json::{Value, from_str};
 
 use crate::{
     context::{file_system::FileSystem, node_scope::NodeScope},
     executor::executor::Executor,
+    logger::logger::Logger,
     repokit::{
         repokit_command::RepoKitCommand, repokit_config::RepoKitConfig,
         repokit_runtime::RepoKitRuntime,
     },
 };
 
+static BRIDGE_PARSING_REGEX: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r#"=============== REPOKIT PARSE FLAG ===============(.*)=============== REPOKIT PARSE FLAG ==============="#).unwrap()
+});
+
 pub struct TypeScriptBridge;
 
 impl TypeScriptBridge {
@@ -27,14 +33,14 @@ impl TypeScriptBridge {
         if stdout.is_empty() {
             RepoKitConfig::create(files);
         }
-        let result: Result<Value, serde_json::Error> = from_str(stdout.as_str());
-        match result {
-            Ok(config) => RepoKitConfig::from_input(&files.git_root, node, config),
-            Err(_) => {
-                RepoKitConfig::on_parsing_error(&files.git_root, node, Value::Null);
-                panic!();
+        if let Some(parsed_config) = TypeScriptBridge::unwrap_stdout(&stdout) {
+            let parse_result: Result<Value, serde_json::Error> = from_str(parsed_config);
+            if let Ok(config) = parse_result {
+                return RepoKitConfig::from_input(&files.git_root, node, config);
             }
         }
+        Logger::parse_error("configuration", &stdout);
+        panic!();
     }
 
     pub fn parse_commands(path_list: &MutexGuard<Vec<String>>) -> Vec<RepoKitCommand> {
@@ -50,14 +56,15 @@ impl TypeScriptBridge {
                 .as_str(),
             )
         });
-        let result: Result<Vec<Value>, serde_json::Error> = serde_json::from_str(&stdout);
-        match result {
-            Ok(commands) => RepoKitCommand::from_input(commands),
-            Err(_) => {
-                RepoKitCommand::full_blown_crash();
-                panic!();
+        if let Some(parsed_commands) = TypeScriptBridge::unwrap_stdout(&stdout) {
+            let parse_result: Result<Vec<Value>, serde_json::Error> =
+                serde_json::from_str(parsed_commands);
+            if let Ok(commands) = parse_result {
+                return RepoKitCommand::from_input(commands);
             }
         }
+        Logger::parse_error("commands", &stdout);
+        panic!();
     }
 
     fn execute_with_node(root: &PathBuf, args: &str) -> String {
@@ -65,4 +72,13 @@ impl TypeScriptBridge {
             cmd.current_dir(Path::new(root))
         })
     }
+
+    fn unwrap_stdout(stdout: &str) -> Option<&str> {
+        if let Some(capture) = BRIDGE_PARSING_REGEX.captures(stdout)
+            && let Some(result) = capture.get(1)
+        {
+            return Some(result.as_str());
+        }
+        None
+    }
 }

package/internals/file_walker/file_walker.rs

@@ -2,7 +2,10 @@ use std::sync::{Arc, Mutex, MutexGuard};
 
 use ignore::WalkBuilder;
 
-use crate::{file_walker::walker::TSFileVisitorBuilder, repokit::repokit_runtime::RepoKitRuntime};
+use crate::{
+    file_walker::walker::{TSFileVisitor, TSFileVisitorBuilder},
+    repokit::repokit_runtime::RepoKitRuntime,
+};
 
 pub struct FileWalker {
     pub command_paths: Arc<Mutex<Vec<String>>>,
@@ -47,13 +50,20 @@ impl FileWalker {
     }
 
     fn from_cache(&self) {
-        let mut paths_to_search = self.command_paths.lock().unwrap();
         RepoKitRuntime::with_runtime(|runtime| {
+            let mut paths_to_search = self.command_paths.lock().unwrap();
             if let Some(files_to_crawl) = &runtime.caches.crawl_cache.files_to_crawl {
                 for file in files_to_crawl {
                     paths_to_search.push(file.to_owned());
                 }
             }
-        })
+            if let Some(changed_files) = &runtime.caches.crawl_cache.changed_files {
+                let mut paths_to_import =
+                    TSFileVisitor::traverse_list(&runtime.git.root, changed_files.to_owned());
+                if !paths_to_import.is_empty() {
+                    paths_to_search.append(&mut paths_to_import);
+                }
+            }
+        });
     }
 }

package/internals/file_walker/walker.rs

@@ -1,11 +1,13 @@
 use std::{
     fs::File,
     io::{BufRead, BufReader},
-    sync::{Arc, Mutex},
+    path::Path,
+    sync::{Arc, LazyLock, Mutex},
 };
 
 use ignore::{DirEntry, Error, ParallelVisitor, ParallelVisitorBuilder, WalkState};
 use regex::Regex;
+use tokio::task::JoinSet;
 
 use crate::{internal_filesystem::file_builder::FileBuilder, logger::logger::Logger};
 
@@ -14,47 +16,80 @@ pub struct TSFileVisitor {
     paths: Arc<Mutex<Vec<String>>>,
 }
 
+static REPOKIT_IMPORT_MATCHER: LazyLock<Regex> = LazyLock::new(|| {
+    Regex::new(r#"(require\(|from[\s*]?)['"]@repokit/core["'][\)]?[;]?$"#).unwrap()
+});
+
 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();
-        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") {
-                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;
-                    }
+        if let Ok(file_entry) = entry
+            && file_entry.file_type().is_some_and(|ft| ft.is_file())
+            && file_entry.file_name().to_string_lossy().ends_with(".ts")
+            && let Some(matched_path) = TSFileVisitor::on_file(file_entry.path())
+        {
+            let mut vector = self.paths.lock().unwrap();
+            vector.push(matched_path.to_string_lossy().replace(&root_replacer, ""));
+        }
+
+        WalkState::Continue
+    }
+}
+
+impl TSFileVisitor {
+    #[tokio::main]
+    pub async fn traverse_list(root: &str, path_list: Vec<String>) -> Vec<String> {
+        let mut handles = JoinSet::new();
+        let root_replacer = format!("{}/", root);
+        for path in path_list {
+            handles.spawn(async move {
+                if let Some(result) = TSFileVisitor::on_file(Path::new(&path)) {
+                    return Some(result.to_owned());
                 }
+                None
+            });
+        }
+        handles
+            .join_all()
+            .await
+            .iter()
+            .filter_map(|result| {
+                result
+                    .as_ref()
+                    .map(|path| path.to_string_lossy().replace(&root_replacer, ""))
+            })
+            .collect()
+    }
+
+    pub fn on_file(path: &Path) -> Option<&Path> {
+        let mut open_comment = false;
+        let file: File = FileBuilder::open(path, |_| 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.ends_with("*/") {
+                    open_comment = false;
+                }
+                continue;
+            }
+            if REPOKIT_IMPORT_MATCHER.is_match(line) {
+                return Some(path);
+            }
+            if !line.is_empty()
+                && !line.starts_with("import ")
+                && !line.contains("require(")
+                && !(line.starts_with("//") || line.starts_with("/*"))
+            {
+                break;
             }
         }
-        WalkState::Continue
+        None
     }
 }
 
@@ -72,8 +107,8 @@ impl<'a> TSFileVisitorBuilder<'a> {
 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(),
+            paths: self.paths.clone(),
         })
     }
 }

package/internals/logger/logger.rs

@@ -55,6 +55,20 @@ impl Logger {
         })
     }
 
+    pub fn parse_error(file_type: &str, stdout: &str) {
+        Logger::info(format!("There was an error parsing your {}", file_type).as_str());
+        Logger::info(
+            "This can occur when RepoKit attempts to parse a TypeScript file that can terminate the process upon evaluation",
+        );
+        Logger::info("Please file a bug to with any related error or stack trace found below");
+        Logger::log_issue_link();
+        println!();
+        if !stdout.is_empty() {
+            println!("{stdout}");
+        }
+        panic!();
+    }
+
     pub fn space_around(message: &str) {
         println!("\n{}{}\n", Logger::info_prefix(), message);
     }

package/internals/repokit/repokit_command.rs

@@ -73,32 +73,6 @@ impl RepoKitCommand {
         None
     }
 
-    pub fn full_blown_crash() {
-        Logger::error("I hit a snag parsing your commands");
-        Logger::error(
-            format!(
-                "This kind of error is indicative of a bug within {}",
-                Logger::with_theme(|theme| theme.highlight("Repokit"))
-            )
-            .as_str(),
-        );
-        println!();
-        Logger::info("Let's blaim the AI's for this one");
-        let version = RepoKitRuntime::with_runtime(|runtime| {
-            runtime.caches.version_cache.installed_version.clone()
-        });
-        Logger::info(
-            format!(
-                "In the interim, please file a bug here and downgrade to the most recent version behind {}",
-                Logger::with_theme(|theme| theme.highlight(&version))
-            )
-            .as_str(),
-        );
-        Logger::log_issue_link();
-        Logger::info("We'll get a hotfix out asap!");
-        panic!();
-    }
-
     fn register_encountered_errors(failed_paths: Vec<String>) {
         PostProcessor::get().register_task(move || {
             println!();

package/internals/repokit/repokit_config.rs

@@ -74,12 +74,14 @@ impl RepoKitConfig {
         if path.exists() {
             Logger::info(
                 format!(
-                    "I found a Repokit configuration without an exported {} instance",
+                    "I found a Repokit configuration but could not resolve the exported {} instance",
                     Logger::with_theme(|theme| theme.highlight("RepokitConfig"))
                 )
                 .as_str(),
             );
-            return Logger::exit_with_info("Please create an instance and export it");
+            Logger::exit_with_info(
+                "Please double check that your config file is free of any sideffects that can cause the parser to crash",
+            );
         }
         Logger::info("Welcome to Repokit! Let's get you setup");
         Logger::info("Creating your configuration file:");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "4.0.4",
+  "version": "4.0.5",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",