@repokit/core 3.0.2 → 3.0.3

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "repokit"
-version = "3.0.2"
+version = "3.0.3"
 edition = "2024"
 
 [[bin]]
@@ -8,6 +8,7 @@ name = "repokit"
 path = "internals/main.rs"
 
 [dependencies]
+jsonschema = { version = "0.45.0", default-features = false }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 colored = "3"
@@ -17,3 +18,5 @@ tokio = "1.50.0"
 ignore = "0.4.25"
 regex = { version = "1.12.3", features = ["std", "unicode"] }
 shellexpand = "3.1.2"
+schemars = "1.2.1"
+terminal-spinners = "0.3.2"

package/dist/CommandParser.mjs

@@ -9,12 +9,12 @@ var CommandParser = class extends TSCompiler {
 	static async parse() {
 		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(join(root, path)));
+		const commands = paths.split(",").filter(Boolean).map((path) => this.parseCommand(root, path));
 		console.log(JSON.stringify(commands.flat()));
 	}
-	static parseCommand(path) {
+	static parseCommand(root, path) {
 		const commands = [];
-		const declaredExports = super.compile(path);
+		const declaredExports = super.compile(join(root, path));
 		for (const key in declaredExports) if (declaredExports[key] instanceof RepoKitCommand) commands.push({
 			...declaredExports[key],
 			location: path

package/externals/CommandParser.ts

@@ -14,13 +14,13 @@ export class CommandParser extends TSCompiler {
       return console.log(JSON.stringify([]));
     }
     const pathList = paths.split(",").filter(Boolean);
-    const commands = pathList.map(path => this.parseCommand(join(root, path)));
+    const commands = pathList.map(path => this.parseCommand(root, path));
     console.log(JSON.stringify(commands.flat()));
   }
 
-  private static parseCommand(path: string) {
+  private static parseCommand(root: string, path: string) {
     const commands: ILocatedCommand[] = [];
-    const declaredExports = super.compile(path);
+    const declaredExports = super.compile(join(root, path));
     for (const key in declaredExports) {
       if (declaredExports[key] instanceof RepoKitCommand) {
         commands.push({ ...declaredExports[key], location: path });

package/installation/install.sh

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

package/internals/configuration/configuration.rs

@@ -1,8 +1,9 @@
-use std::{path::Path, process::exit};
+use std::path::Path;
 
 use crate::{
     internal_filesystem::{file_builder::FileBuilder, internal_filesystem::InternalFileSystem},
     logger::logger::Logger,
+    post_processing::post_processor::PostProcessor,
 };
 
 pub struct Configuration;
@@ -34,7 +35,7 @@ impl Configuration {
             .as_str(),
         );
         Logger::log_file_path(file_path.as_str());
-        exit(0);
+        PostProcessor::get().flush();
     }
 
     fn welcome() {

package/internals/configuration/mod.rs

@@ -1 +1,3 @@
 pub mod configuration;
+pub mod recovery;
+pub mod typescript_command;

package/internals/configuration/recovery.rs

@@ -0,0 +1,42 @@
+use crate::{
+    executor::executor::Executor, internal_filesystem::internal_filesystem::InternalFileSystem,
+    logger::logger::Logger,
+};
+
+pub struct Recovery {
+    root: String,
+}
+
+impl Recovery {
+    pub fn new(root: &str) -> Recovery {
+        Recovery {
+            root: root.to_owned(),
+        }
+    }
+
+    pub fn run(&mut self, file_path: &str) {
+        let command = self.get_typecheck_command(file_path);
+        Executor::with_stdio(command, |cmd| cmd);
+    }
+
+    pub fn get_typecheck_command(&self, file_path: &str) -> String {
+        let executor = InternalFileSystem::get_node_executor(&self.root);
+        let typescript_version = InternalFileSystem::get_typescript_version(executor);
+        let ignore_config = if typescript_version >= 6 {
+            " --ignoreConfig".to_string()
+        } else {
+            "".to_string()
+        };
+        let tsc_command = format!("{} tsc {} --noEmit{}", executor, file_path, ignore_config);
+        tsc_command
+    }
+
+    pub fn prompt_to_fix_errors(&self, config_path: &str) {
+        Logger::info(
+            "Please fix the above type-errors and rerun your command"
+                .to_string()
+                .as_str(),
+        );
+        Logger::log_file_path(config_path);
+    }
+}

package/internals/{internal_commands → configuration}/typescript_command.rs

@@ -1,13 +1,16 @@
 use std::{path::Path, process::exit, sync::MutexGuard};
 
-use serde_json::from_str;
+use serde_json::{Value, from_str};
 
 use crate::{
     configuration::configuration::Configuration,
     executor::executor::Executor,
     internal_filesystem::internal_filesystem::InternalFileSystem,
-    logger::logger::Logger,
-    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
+    post_processing::post_processor::PostProcessor,
+    repokit::{
+        repokit_command::RepoKitCommand, repokit_config::RepoKitConfig,
+        repokit_construct_validator::RepoKitConstructValidator,
+    },
 };
 
 pub struct TypescriptCommand {
@@ -17,7 +20,7 @@ pub struct TypescriptCommand {
 impl TypescriptCommand {
     pub fn new(root: &str) -> TypescriptCommand {
         TypescriptCommand {
-            root: root.to_string(),
+            root: root.to_owned(),
         }
     }
 
@@ -27,8 +30,15 @@ impl TypescriptCommand {
         if stdout.is_empty() {
             Configuration::create(&self.root);
         }
-        let config: RepoKitConfig = from_str(stdout.as_str()).unwrap();
-        config
+        let result: Result<Value, serde_json::Error> = from_str(stdout.as_str());
+        match result {
+            Ok(config) => RepoKitConfig::from_input(&self.root, config),
+            Err(_) => {
+                RepoKitConfig::on_parsing_error(&self.root, Value::Null);
+                PostProcessor::get().flush();
+                exit(0)
+            }
+        }
     }
 
     pub fn parse_commands(&self, path_list: &MutexGuard<Vec<String>>) -> Vec<RepoKitCommand> {
@@ -36,24 +46,12 @@ impl TypescriptCommand {
         let executable = InternalFileSystem::new(&self.root).resolve_command("parse_commands");
         let stdout =
             self.execute(format!("{executable} --paths {paths} --root {}", self.root).as_str());
-        let result: Result<Vec<RepoKitCommand>, serde_json::Error> = serde_json::from_str(&stdout);
+        let result: Result<Vec<Value>, serde_json::Error> = serde_json::from_str(&stdout);
         match result {
-            Ok(mut commands) => {
-                for command in commands.iter_mut() {
-                    let relative_location = &command.location;
-                    command.location = Path::join(Path::new(&self.root), relative_location)
-                        .to_str()
-                        .expect("str")
-                        .to_string()
-                }
-                commands
-            }
+            Ok(commands) => RepoKitCommand::from_input(&self.root, 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");
+                RepoKitCommand::on_parsing_error(&self.root, Value::Null);
+                PostProcessor::get().flush();
                 exit(0);
             }
         }

package/internals/executables/internal_executable_definition.rs

@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use crate::repokit::interfaces::RepoKitConfig;
+use crate::repokit::repokit_config::RepoKitConfig;
 
 #[derive(Clone)]
 pub struct RepoKitScope {

package/internals/executables/mod.rs

@@ -1,3 +1,2 @@
-pub mod external_executable;
-pub mod intenal_executable;
+pub mod internal_executable;
 pub mod internal_executable_definition;

package/internals/executor/executor.rs

@@ -18,6 +18,19 @@ impl Executor {
         Executor::unwrap(&output.stderr)
     }
 
+    pub fn exec_with_errors<T: AsRef<OsStr>>(
+        command: T,
+        composer: impl Fn(&mut Command) -> &mut Command,
+    ) -> Option<String> {
+        let output = composer(&mut Executor::spawn(command))
+            .output()
+            .expect("command failed to execute");
+        if output.status.success() {
+            return None;
+        }
+        Some(Executor::unwrap(&output.stderr))
+    }
+
     pub fn with_stdio<T: AsRef<OsStr>>(
         command: T,
         composer: impl Fn(&mut Command) -> &mut Command,

package/internals/internal_commands/help.rs

@@ -4,11 +4,14 @@ use alphanumeric_sort::{sort_slice_by_str_key, sort_str_slice};
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable,
+        internal_executable::InternalExecutable,
         internal_executable_definition::InternalExecutableDefinition,
     },
     logger::logger::Logger,
-    repokit::interfaces::{CommandDefinition, RepoKitCommand, RootCommand},
+    repokit::{
+        command_definition::CommandDefinition, repokit_command::RepoKitCommand,
+        repokit_config::RootCommand,
+    },
 };
 
 pub struct Help;

package/internals/internal_commands/internal_registry.rs

@@ -2,12 +2,13 @@ use std::collections::HashMap;
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
+        internal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
     },
     internal_commands::{
         list_commands::ListCommands, list_owners::ListOwners, list_themes::ListThemes,
-        locate_command::LocateCommand, onboarder::Onboarder, register_command::RegisterCommand,
-        search_commands::SearchCommands, upgrade_repokit::UpgradeRepoKit,
+        list_version::ListVersion, locate_command::LocateCommand, onboarder::Onboarder,
+        register_command::RegisterCommand, search_commands::SearchCommands,
+        upgrade_repokit::UpgradeRepoKit,
     },
 };
 
@@ -23,7 +24,7 @@ impl InternalRegistry {
     }
 
     pub fn get_all(&self) -> HashMap<String, Box<dyn InternalExecutable>> {
-        let internals: [Box<dyn InternalExecutable>; 8] = [
+        let internals: [Box<dyn InternalExecutable>; 9] = [
             Box::new(Onboarder::new(&self.scope)),
             Box::new(ListCommands::new(&self.scope)),
             Box::new(SearchCommands::new(&self.scope)),
@@ -32,6 +33,7 @@ impl InternalRegistry {
             Box::new(RegisterCommand::new(&self.scope)),
             Box::new(UpgradeRepoKit::new(&self.scope)),
             Box::new(ListThemes::new(&self.scope)),
+            Box::new(ListVersion::new(&self.scope)),
         ];
         HashMap::from(internals.map(|x| (x.get_definition().name.to_string(), x)))
     }

package/internals/internal_commands/list_commands.rs

@@ -2,14 +2,14 @@ use std::collections::HashMap;
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable,
+        internal_executable::InternalExecutable,
         internal_executable_definition::{
             InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::interfaces::RepoKitCommand,
+    repokit::repokit_command::RepoKitCommand,
     validations::command_validations::CommandValidations,
 };
 

package/internals/internal_commands/list_owners.rs

@@ -4,14 +4,14 @@ use alphanumeric_sort::sort_str_slice;
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable,
+        internal_executable::InternalExecutable,
         internal_executable_definition::{
             InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::interfaces::RepoKitCommand,
+    repokit::repokit_command::RepoKitCommand,
     validations::command_validations::CommandValidations,
 };
 

package/internals/internal_commands/list_themes.rs

@@ -6,7 +6,7 @@ use colored::Colorize;
 use crate::{
     argv::argv::{Argv, ArgvOption, ArgvType},
     executables::{
-        intenal_executable::InternalExecutable,
+        internal_executable::InternalExecutable,
         internal_executable_definition::{
             InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },

package/internals/internal_commands/list_version.rs

@@ -0,0 +1,60 @@
+use std::collections::HashMap;
+
+use crate::{
+    executables::{
+        internal_executable::InternalExecutable,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
+        },
+    },
+    executor::executor::Executor,
+    internal_commands::help::Help,
+    internal_filesystem::internal_filesystem::InternalFileSystem,
+    logger::logger::Logger,
+};
+
+pub struct ListVersion {
+    pub scope: RepoKitScope,
+    pub definition: InternalExecutableDefinition,
+}
+
+impl ListVersion {
+    pub fn new(scope: &RepoKitScope) -> ListVersion {
+        ListVersion {
+            scope: scope.clone(),
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
+                name: "version",
+                description: "Lists the version of repokit running in this repository",
+                args: [],
+            }),
+        }
+    }
+
+    fn log_version(&self, version: &str) {
+        Logger::info(format!("{}", Logger::with_theme(|theme| theme.highlight(version))).as_str());
+    }
+}
+
+impl InternalExecutable for ListVersion {
+    fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
+        Logger::info("Fetching the installed version of repokit");
+        if let Some(local_version) =
+            InternalFileSystem::new(&self.scope.root).installed_repokit_version()
+        {
+            return self.log_version(&local_version);
+        }
+        Logger::info("Falling back to the runtime version");
+        if let Some(runtime_version) = InternalFileSystem::runtime_repokit_version() {
+            return self.log_version(&runtime_version);
+        }
+        Executor::with_stdio("npm list @repokit/core", |cmd| cmd);
+    }
+
+    fn help(&self) {
+        Help::log_internal_command(&self.definition);
+    }
+
+    fn get_definition(&self) -> &InternalExecutableDefinition {
+        &self.definition
+    }
+}

package/internals/internal_commands/locate_command.rs

@@ -1,14 +1,15 @@
-use std::{collections::HashMap, process::exit};
+use std::collections::HashMap;
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable,
+        internal_executable::InternalExecutable,
         internal_executable_definition::{
             InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
+    post_processing::post_processor::PostProcessor,
     validations::command_validations::CommandValidations,
 };
 
@@ -35,7 +36,7 @@ impl LocateCommand {
         for (_, command) in all {
             if command.name == query {
                 Logger::log_file_path(&command.location);
-                exit(0);
+                PostProcessor::get().flush();
             }
         }
     }
@@ -43,7 +44,7 @@ impl LocateCommand {
     fn search_root(&self, command: &str) {
         if self.scope.configuration.commands.contains_key(command) {
             Logger::log_file_path(format!("{}/repokit.ts", &self.scope.root).as_str());
-            exit(0);
+            PostProcessor::get().flush();
         }
     }
 }

package/internals/internal_commands/mod.rs

@@ -3,9 +3,9 @@ pub mod internal_registry;
 pub mod list_commands;
 pub mod list_owners;
 pub mod list_themes;
+pub mod list_version;
 pub mod locate_command;
 pub mod onboarder;
 pub mod register_command;
 pub mod search_commands;
-pub mod typescript_command;
 pub mod upgrade_repokit;

package/internals/internal_commands/onboarder.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable,
+        internal_executable::InternalExecutable,
         internal_executable_definition::{
             InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },

package/internals/internal_commands/register_command.rs

@@ -2,12 +2,11 @@ use normalize_path::NormalizePath;
 use std::{
     collections::HashMap,
     path::{Path, PathBuf},
-    process,
 };
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable,
+        internal_executable::InternalExecutable,
         internal_executable_definition::{
             InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
@@ -15,6 +14,7 @@ use crate::{
     internal_commands::help::Help,
     internal_filesystem::{file_builder::FileBuilder, internal_filesystem::InternalFileSystem},
     logger::logger::Logger,
+    post_processing::post_processor::PostProcessor,
 };
 
 pub struct RegisterCommand {
@@ -72,7 +72,7 @@ impl RegisterCommand {
                 "You can append additional commands to the existing {} instance or export another one",
                 Logger::with_theme(|theme| theme.highlight("RepoKitCommand"))
             ).as_str());
-            process::exit(0);
+            PostProcessor::get().flush();
         }
         command_path.clone()
     }

package/internals/internal_commands/search_commands.rs

@@ -3,14 +3,14 @@ use std::collections::HashMap;
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable,
+        internal_executable::InternalExecutable,
         internal_executable_definition::{
             InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::interfaces::{CommandDefinition, RepoKitCommand},
+    repokit::{command_definition::CommandDefinition, repokit_command::RepoKitCommand},
     validations::command_validations::CommandValidations,
 };
 

package/internals/internal_commands/upgrade_repokit.rs

@@ -1,15 +1,17 @@
-use normalize_path::NormalizePath;
-use std::{collections::HashMap, path::Path, process::exit};
+use std::collections::HashMap;
+
+use terminal_spinners::{BOUNCING_BALL, SpinnerBuilder};
 
 use crate::{
     executables::{
-        intenal_executable::InternalExecutable,
+        internal_executable::InternalExecutable,
         internal_executable_definition::{
             InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     executor::executor::Executor,
     internal_commands::help::Help,
+    internal_filesystem::internal_filesystem::InternalFileSystem,
     logger::logger::Logger,
 };
 
@@ -30,43 +32,44 @@ impl UpgradeRepoKit {
         }
     }
 
-    fn get_package_manager(&self) -> &str {
-        let manager_map = HashMap::from([
-            ("npm", ("package-lock.json", "npm i -D")),
-            ("yarn", ("yarn.lock", "yarn add -D")),
-            ("pnpm", ("pnpm-lock.yaml", "pnpm i -D")),
-            ("bun", ("bun.lockb", "bun add -d")),
-        ]);
-        for (manager, (lock_file, command_prefix)) in manager_map {
-            let path = Path::new(&self.scope.root).join(lock_file).normalize();
-            if path.exists() && path.is_file() {
-                Logger::info(
-                    format!(
-                        "Detected {} installation",
-                        Logger::with_theme(|theme| theme.highlight(manager))
-                    )
-                    .as_str(),
-                );
-                return command_prefix;
-            }
-        }
-        Logger::info("A node package manager was not detected");
-        Logger::info(
-            "To upgrade repokit install the latest version using the package manager of your choosing",
+    pub fn static_execute(root: &str) {
+        Logger::info("Upgrading installation");
+        let handle = SpinnerBuilder::new()
+            .spinner(&BOUNCING_BALL)
+            .text(" Installing")
+            .start();
+        let command_prefix = InternalFileSystem::get_install_command(root);
+        Executor::exec(
+            format!("{} @repokit/core@latest", command_prefix).as_str(),
+            |cmd| cmd.current_dir(root),
         );
-        exit(0);
+        handle.done();
     }
 }
 
 impl InternalExecutable for UpgradeRepoKit {
     fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
-        Logger::info("Upgrading installation");
-        let command_prefix = self.get_package_manager();
-        Executor::exec(
-            format!("{} @repokit/core@latest", command_prefix).as_str(),
-            |cmd| cmd.current_dir(&self.scope.root),
-        );
-        Logger::info("Upgrade complete!");
+        let internal_fs = InternalFileSystem::new(&self.scope.root);
+        let fallback = "unknown";
+        let runtime_version = internal_fs
+            .installed_repokit_version()
+            .unwrap_or(fallback.to_string());
+        UpgradeRepoKit::static_execute(&self.scope.root);
+        let installed_version = internal_fs
+            .installed_repokit_version()
+            .unwrap_or(fallback.to_string());
+        if runtime_version != installed_version {
+            Logger::info("Upgrade Complete!");
+            Logger::info(
+                format!(
+                    "The currently installed version is {}",
+                    Logger::with_theme(|theme| theme.highlight(&installed_version))
+                )
+                .as_str(),
+            );
+        } else {
+            Logger::info("The latest version is already installed");
+        }
     }
 
     fn help(&self) {

package/internals/internal_filesystem/file_builder.rs

@@ -1,3 +1,4 @@
+use crate::post_processing::post_processor::PostProcessor;
 use std::{
     fs::{File, create_dir_all},
     io::{Error, copy},
@@ -14,6 +15,7 @@ impl FileBuilder {
             Ok(file) => file,
             Err(error) => {
                 on_error(error);
+                PostProcessor::get().flush();
                 exit(0);
             }
         }
@@ -25,6 +27,7 @@ impl FileBuilder {
             Ok(file) => file,
             Err(error) => {
                 on_error(error);
+                PostProcessor::get().flush();
                 exit(0);
             }
         }
@@ -50,6 +53,7 @@ impl FileBuilder {
             Ok(result) => result,
             Err(error) => {
                 on_error(error);
+                PostProcessor::get().flush();
                 exit(0);
             }
         }