@repokit/core 0.0.1

package/workspaces/internal_commands/register_command.rs

@@ -0,0 +1,117 @@
+use normalize_path::NormalizePath;
+use std::{
+    collections::HashMap,
+    fs::{File, create_dir_all},
+    io,
+    path::{Path, PathBuf},
+    process,
+};
+
+use crate::{
+    repokit::interfaces::RepoKitConfig,
+    executables::{
+        intenal_executable::InternalExecutable,
+        internal_executable_definition::InternalExecutableDefinition,
+    },
+    internal_commands::help::Help,
+    logger::logger::Logger,
+};
+
+pub struct RegisterCommand {
+    pub root: String,
+    pub configuration: RepoKitConfig,
+    pub definition: InternalExecutableDefinition,
+}
+
+impl RegisterCommand {
+    pub fn new(root: String, configuration: RepoKitConfig) -> RegisterCommand {
+        RegisterCommand {
+            root,
+            configuration,
+            definition: InternalExecutableDefinition {
+                name: "register",
+                description: "Creates new Repokit commands",
+                args: HashMap::from([(
+                    "<path>",
+                    "A relative path to your preferred command location",
+                )]),
+            },
+        }
+    }
+
+    fn validate_path(&self, args: Vec<String>) -> PathBuf {
+        if args.is_empty() {
+            RegisterCommand::exit_on_missing_path();
+        }
+        let path_arg = args[0].clone();
+        if path_arg.is_empty() {
+            RegisterCommand::exit_on_missing_path();
+        }
+        let path = Path::new(&self.root).join(&path_arg).normalize();
+        if !path.exists() {
+            Logger::info(
+                format!(
+                    "Creating the path {} in your file system",
+                    Logger::blue_bright(path_arg.as_str())
+                )
+                .as_str(),
+            );
+            create_dir_all(&path).expect("");
+        }
+        if !path.is_dir() {
+            RegisterCommand::exit_on_missing_path();
+        }
+        let command_path = &path.join("Commands.ts");
+        if command_path.exists() {
+            Logger::error(
+                format!(
+                    "A {} file already exists in this directory",
+                    Logger::blue_bright("Commands.ts")
+                )
+                .as_str(),
+            );
+            Logger::info(format!(
+                "You can append additional commands to the existing {} instance or export another one",
+                Logger::blue_bright("RepoKitCommand")
+            ).as_str());
+            process::exit(0);
+        }
+        command_path.clone()
+    }
+
+    fn exit_on_missing_path() {
+        Logger::exit_with_error(
+            "Please specify a path to a directory relative to the root of your repository",
+        );
+    }
+
+    pub fn template_path() -> PathBuf {
+        let file_path = file!();
+        let dir = Path::new(file_path)
+            .parent()
+            .expect("Failed to get parent directory");
+        dir.join("command_template.ts")
+    }
+}
+
+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 mut source = File::open(RegisterCommand::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");
+        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"));
+    }
+
+    fn help(&self) {
+        Help::log_internal_command(&self.definition);
+    }
+
+    fn get_definition(&self) -> &InternalExecutableDefinition {
+        &self.definition
+    }
+}

package/workspaces/internal_commands/search_commands.rs

@@ -0,0 +1,189 @@
+use alphanumeric_sort::sort_slice_by_str_key;
+use std::collections::HashMap;
+
+use crate::{
+    repokit::interfaces::{Command, RepoKitCommand, RepoKitConfig},
+    executables::{
+        intenal_executable::InternalExecutable,
+        internal_executable_definition::InternalExecutableDefinition,
+    },
+    internal_commands::help::Help,
+    logger::logger::Logger,
+    validations::command_validations::CommandValidations,
+};
+
+pub struct SearchCommands {
+    pub root: String,
+    pub configuration: RepoKitConfig,
+    pub definition: InternalExecutableDefinition,
+}
+
+impl SearchCommands {
+    pub fn new(root: String, configuration: RepoKitConfig) -> SearchCommands {
+        SearchCommands {
+            root,
+            configuration,
+            definition: InternalExecutableDefinition {
+                name: "search",
+                description: "Retrieve commands that match any search query",
+                args: HashMap::from([(
+                    "<query>",
+                    "A search string to match against command names, descriptions, arguments, or owner",
+                )]),
+            },
+        }
+    }
+
+    fn search_internal(&self, query: &str, command: &Box<dyn InternalExecutable>) -> bool {
+        let config = command.get_definition();
+        if config.name.to_lowercase().contains(query) {
+            return true;
+        }
+        if config.description.to_lowercase().contains(query) {
+            return true;
+        }
+        for (arg, description) in &config.args {
+            if arg.to_lowercase().contains(query) || description.to_lowercase().contains(query) {
+                return true;
+            }
+        }
+        false
+    }
+
+    fn search_external(&self, query: &str, command: &RepoKitCommand) -> bool {
+        if command.name.to_lowercase().contains(query) {
+            return true;
+        }
+        if command.owner.to_lowercase().contains(query) {
+            return true;
+        }
+        if command
+            .location
+            .replace(self.root.as_str(), "")
+            .to_lowercase()
+            .contains(query)
+        {
+            return true;
+        }
+        if command.description.to_lowercase().contains(query) {
+            return true;
+        }
+        for (arg, sub_command) in &command.commands {
+            if arg.to_lowercase().contains(query) || self.search_command(query, sub_command) {
+                return true;
+            }
+        }
+        false
+    }
+
+    fn search_command(&self, query: &str, command: &Command) -> bool {
+        if command.command.to_lowercase().contains(query)
+            || command.description.to_lowercase().contains(query)
+        {
+            return true;
+        }
+        false
+    }
+
+    fn log_root_results(&self, root_results: &HashMap<String, Command>) {
+        let total = root_results.len();
+        let plural_appendage = if total == 1 { "" } else { "s" };
+        if !root_results.is_empty() {
+            Help::log_root_commands(root_results);
+        }
+        Logger::info(
+            format!(
+                "Matched {} command{} in your repokit config",
+                Logger::blue_bright(total.to_string().as_str()),
+                plural_appendage,
+            )
+            .as_str(),
+        );
+    }
+
+    fn log_internal_results(
+        &self,
+        internal_results: &HashMap<String, &Box<dyn InternalExecutable>>,
+    ) {
+        let total = internal_results.len();
+        let plural_appendage = if total == 1 { "" } else { "s" };
+        if !internal_results.is_empty() {
+            let mut sorted_internals: Vec<&&Box<dyn InternalExecutable>> =
+                internal_results.values().collect();
+            sort_slice_by_str_key(&mut sorted_internals, |x| &x.get_definition().name);
+            Logger::space_around("Internal Commands:");
+            for internal in sorted_internals {
+                internal.help();
+                println!();
+            }
+        }
+        Logger::info(
+            format!(
+                "Matched {} internal command{}",
+                Logger::blue_bright(total.to_string().as_str()),
+                plural_appendage,
+            )
+            .as_str(),
+        );
+    }
+
+    fn log_external_results(&self, external_commands: &HashMap<String, RepoKitCommand>) {
+        let total = external_commands.len();
+        let plural_appendage = if total == 1 { "" } else { "s" };
+        if !external_commands.is_empty() {
+            Help::log_external_commands(external_commands);
+        }
+        Logger::info(
+            format!(
+                "Matched {} registered command{}",
+                Logger::blue_bright(total.to_string().as_str()),
+                plural_appendage,
+            )
+            .as_str(),
+        );
+    }
+}
+
+impl InternalExecutable for SearchCommands {
+    fn run(&self, args: Vec<String>, internals: &HashMap<String, Box<dyn InternalExecutable>>) {
+        Logger::info("Searching commands");
+        if args.is_empty() {
+            Logger::exit_with_error("Please specify a search string to query with");
+        }
+        let query = args.join(" ").to_lowercase();
+        let externals = CommandValidations::new(self.root.clone(), self.configuration.clone())
+            .collect_and_validate_externals();
+        let mut root_results: HashMap<String, Command> = HashMap::new();
+        let mut internal_results: HashMap<String, &Box<dyn InternalExecutable>> = HashMap::new();
+        let mut external_results: HashMap<String, RepoKitCommand> = HashMap::new();
+        for (command, script) in &self.configuration.commands {
+            if self.search_command(&query, script) {
+                root_results.insert(command.clone(), script.clone());
+            }
+        }
+        for (name, command) in internals {
+            if self.search_internal(&query, command) {
+                internal_results.insert(name.clone(), command);
+            }
+        }
+        for (name, command) in externals {
+            if self.search_external(&query, &command) {
+                external_results.insert(name, command);
+            }
+        }
+        if root_results.is_empty() && internal_results.is_empty() && external_results.is_empty() {
+            Logger::exit_with_info("No matched commands");
+        }
+        self.log_root_results(&root_results);
+        self.log_internal_results(&internal_results);
+        self.log_external_results(&external_results);
+    }
+
+    fn help(&self) {
+        Help::log_internal_command(&self.definition);
+    }
+
+    fn get_definition(&self) -> &InternalExecutableDefinition {
+        &self.definition
+    }
+}

package/workspaces/internal_commands/typescript_command.rs

@@ -0,0 +1,63 @@
+use std::path::{Path, PathBuf};
+
+use normalize_path::NormalizePath;
+use serde_json::from_str;
+
+use crate::{
+    configuration::configuration::Configuration,
+    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
+    executor::executor::Executor,
+};
+
+pub struct TypescriptCommand {
+    root: String,
+}
+
+impl TypescriptCommand {
+    pub fn new(root: String) -> TypescriptCommand {
+        TypescriptCommand { root }
+    }
+
+    pub fn parse_configuration(&self) -> RepoKitConfig {
+        let executable = self.path_to_command("parse_configuration.ts");
+        let stdout = self.execute(format!("{executable} --root {}", &self.root).as_str());
+        if stdout.is_empty() {
+            Configuration::create(&self.root);
+        }
+        let RepoKitConfig { project, commands } =
+            from_str(stdout.as_str()).expect("Error parsing stdout");
+        RepoKitConfig { project, commands }
+    }
+
+    pub fn parse_commands(&self, path_list: Vec<String>) -> Vec<RepoKitCommand> {
+        let paths = path_list.join(",");
+        let executable = self.path_to_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
+    }
+
+    fn commands_dir(&self) -> PathBuf {
+        let file_path = file!();
+        let dir = Path::new(file_path)
+            .parent()
+            .expect("Failed to get parent directory");
+        let resolved = Path::new(&self.root).join(dir);
+        resolved.join("../../src/commands").normalize()
+    }
+
+    fn path_to_command(&self, command_file: &str) -> String {
+        self.commands_dir()
+            .join(command_file)
+            .into_os_string()
+            .into_string()
+            .expect("Cannot construct path")
+    }
+
+    fn execute(&self, args: &str) -> String {
+        Executor::exec(format!("npx tsx {}", args), |cmd| {
+            cmd.current_dir(Path::new(&self.root))
+        })
+    }
+}

package/workspaces/internal_commands/upgrade_repokit.rs

@@ -0,0 +1,76 @@
+use normalize_path::NormalizePath;
+use std::{collections::HashMap, path::Path, process::exit};
+
+use crate::{
+    executables::{
+        intenal_executable::InternalExecutable,
+        internal_executable_definition::InternalExecutableDefinition,
+    },
+    executor::executor::Executor,
+    internal_commands::help::Help,
+    logger::logger::Logger,
+    repokit::interfaces::RepoKitConfig,
+};
+
+pub struct UpgradeRepoKit {
+    pub root: String,
+    pub configuration: RepoKitConfig,
+    pub definition: InternalExecutableDefinition,
+}
+
+impl UpgradeRepoKit {
+    pub fn new(root: String, configuration: RepoKitConfig) -> UpgradeRepoKit {
+        UpgradeRepoKit {
+            root,
+            configuration,
+            definition: InternalExecutableDefinition {
+                name: "upgrade",
+                description: "Upgrades your installation of repokit to the latest stable version",
+                args: HashMap::from([]),
+            },
+        }
+    }
+
+    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.root).join(lock_file).normalize();
+            if path.exists() && path.is_file() {
+                Logger::info(
+                    format!("Detected {} installation", Logger::blue_bright(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",
+        );
+        exit(0);
+    }
+}
+
+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.root),
+        );
+        Logger::info("Upgrade complete!");
+    }
+
+    fn help(&self) {
+        Help::log_internal_command(&self.definition);
+    }
+
+    fn get_definition(&self) -> &InternalExecutableDefinition {
+        &self.definition
+    }
+}

package/workspaces/logger/logger.rs

@@ -0,0 +1,98 @@
+use std::sync::Mutex;
+use std::{process, sync::LazyLock};
+
+use colored::{ColoredString, Colorize, CustomColor};
+
+static REGISTERED_NAME: LazyLock<Mutex<String>> =
+    LazyLock::new(|| Mutex::new("Repokit".to_string()));
+
+pub struct Logger {}
+
+impl Logger {
+    pub fn set_name(value: &str) {
+        *REGISTERED_NAME.lock().unwrap() = value.to_string();
+    }
+
+    pub fn info(message: &str) {
+        println!("{}{}", Logger::info_prefix(), message);
+    }
+
+    pub fn error(message: &str) {
+        eprintln!("{}{}", Logger::error_prefix(), message);
+    }
+
+    pub fn exit_with_info(message: &str) {
+        Logger::info(message);
+        process::exit(0);
+    }
+
+    pub fn exit_with_error(message: &str) {
+        Logger::error(message);
+        process::exit(0);
+    }
+
+    pub fn space_around(message: &str) {
+        println!("\n{}{}\n", Logger::info_prefix(), message);
+    }
+
+    pub fn log_file_path(path: &str) {
+        println!("\n{}{}\n", Logger::indent(None), Logger::blue_bright(path));
+    }
+
+    pub fn indent(times: Option<i32>) -> String {
+        let indentation: i32 = times.unwrap_or(5);
+        " ".repeat(indentation.try_into().unwrap())
+    }
+
+    pub fn blue(message: &str) -> ColoredString {
+        message.bright_blue()
+    }
+
+    pub fn blue_bright(message: &str) -> ColoredString {
+        message.bright_blue().bold()
+    }
+
+    pub fn magenta_bright(message: &str) -> ColoredString {
+        message.bright_magenta().bold()
+    }
+
+    pub fn magenta(message: &str) -> ColoredString {
+        message.magenta()
+    }
+
+    pub fn green(message: &str) -> ColoredString {
+        message.green()
+    }
+
+    pub fn green_bright(message: &str) -> ColoredString {
+        message.bright_green()
+    }
+
+    pub fn cyan(message: &str) -> ColoredString {
+        message.cyan()
+    }
+
+    pub fn cyan_bright(message: &str) -> ColoredString {
+        message.bright_cyan().bold()
+    }
+
+    pub fn gray(message: &str) -> ColoredString {
+        message.custom_color(CustomColor {
+            r: 128,
+            g: 128,
+            b: 128,
+        })
+    }
+
+    fn info_prefix() -> ColoredString {
+        format!("{}: ", *REGISTERED_NAME.lock().unwrap())
+            .bright_magenta()
+            .bold()
+    }
+
+    fn error_prefix() -> ColoredString {
+        format!("{}: ", *REGISTERED_NAME.lock().unwrap())
+            .red()
+            .bold()
+    }
+}

package/workspaces/logger/mod.rs

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

package/workspaces/main.rs

@@ -0,0 +1,21 @@
+use crate::{
+    executor::executor::Executor, internal_commands::typescript_command::TypescriptCommand,
+    repokit::repokit::RepoKit,
+};
+
+mod concurrency;
+mod configuration;
+mod executables;
+mod executor;
+mod external_commands;
+mod internal_commands;
+mod logger;
+mod repokit;
+mod validations;
+
+fn main() {
+    let root = Executor::exec("git rev-parse --show-toplevel", |cmd| cmd);
+    let config = TypescriptCommand::new(root.clone()).parse_configuration();
+    let kit = RepoKit::new(root, config);
+    kit.invoke();
+}

package/workspaces/repokit/interfaces.rs

@@ -0,0 +1,41 @@
+use std::collections::HashMap;
+
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct Command {
+    pub command: String,
+    pub description: String,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct ParsedCommand {
+    pub name: String,
+    pub command: String,
+    pub description: String,
+}
+
+impl ParsedCommand {
+    pub fn from(name: &str, command: &Command) -> ParsedCommand {
+        ParsedCommand {
+            name: name.to_string(),
+            command: command.command.to_string(),
+            description: command.description.to_string(),
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct RepoKitConfig {
+    pub project: String,
+    pub commands: HashMap<String, Command>,
+}
+
+#[derive(Debug, Deserialize, Clone)]
+pub struct RepoKitCommand {
+    pub name: String,
+    pub owner: String,
+    pub location: String,
+    pub description: String,
+    pub commands: HashMap<String, Command>,
+}

package/workspaces/repokit/mod.rs

@@ -0,0 +1,2 @@
+pub mod interfaces;
+pub mod repokit;