@repokit/core 1.3.6 → 1.3.7

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/walker.rs

@@ -7,6 +7,8 @@ use std::{
 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>>>,
@@ -26,7 +28,7 @@ impl ParallelVisitor for TSFileVisitor {
                 && !template_matcher.is_match(path_string)
             {
                 let mut open_comment = false;
-                let file: File = File::open(path).expect("file");
+                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();

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, sync::MutexGuard};
+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},
 };
 
@@ -36,8 +37,18 @@ impl TypescriptCommand {
         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/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

@@ -98,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.6",
+  "version": "1.3.7",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",
@@ -39,7 +39,7 @@
     "@types/node": "^25.2.1",
     "oxfmt": "^0.33.0",
     "oxlint": "^1.42.0",
-    "oxlint-tsgolint": "^0.13.0",
+    "oxlint-tsgolint": "^0.14.0",
     "typescript": "^5.9.3"
   }
 }