@repokit/core 0.0.1

package/workspaces/external_commands/external_commands.rs

@@ -0,0 +1,125 @@
+use std::{
+    fs::File,
+    io::{BufRead, BufReader},
+    path::Path,
+};
+
+use jwalk::WalkDir;
+
+use crate::{
+    concurrency::thread_pool::ThreadPool, internal_commands::typescript_command::TypescriptCommand,
+    repokit::interfaces::RepoKitCommand,
+};
+
+pub struct ExternalCommands {
+    pub root: String,
+}
+
+impl ExternalCommands {
+    pub fn new(root: String) -> ExternalCommands {
+        ExternalCommands { root }
+    }
+
+    pub async fn find_all(&self) -> Vec<RepoKitCommand> {
+        let mut paths: Vec<String> = vec![];
+        let mut pool = ThreadPool::new(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();
+            let clone = path.clone();
+            let async_task = pool.spawn(move || ExternalCommands::read(&path));
+            if async_task.await.unwrap() {
+                paths.push(
+                    (clone)
+                        .into_os_string()
+                        .into_string()
+                        .expect("stringify")
+                        .replace(&self.root, ""),
+                );
+            }
+        }
+        pool.pool.shutdown_background();
+        TypescriptCommand::new(self.root.clone()).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.contains("new RepoKitCommand(") {
+                return true;
+            }
+        }
+        false
+    }
+
+    fn allowed(&self, path: &str) -> bool {
+        let restricted_paths = ["node_modules", "target", "dist"];
+        let restricted_extensions = ["internal_commands/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/workspaces/external_commands/mod.rs

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

package/workspaces/internal_commands/command_template.ts

@@ -0,0 +1,24 @@
+import { RepoKitCommand } from "@repokit/core";
+
+/**
+ * Please fill out this command file with your desired settings
+ */
+export const Commands = new RepoKitCommand({
+  name: "<Your Package Name>",
+  owner: "<Optional Team or Individual>",
+  description: "<Your Package Description>",
+  commands: {
+    "<your-first-command>": {
+      command: "<insert shell command here>",
+      description: "A description for using your command",
+    },
+    "<your-second-command>": {
+      command: "<insert shell command here>",
+      description: "A description for using your command",
+    },
+    "<your-third-command>": {
+      command: "<insert shell command here>",
+      description: "A description for using your command",
+    },
+  },
+});

package/workspaces/internal_commands/help.rs

@@ -0,0 +1,146 @@
+use std::collections::HashMap;
+
+use alphanumeric_sort::{sort_slice_by_str_key, sort_str_slice};
+
+use crate::{
+    repokit::interfaces::{Command, RepoKitCommand, ParsedCommand},
+    executables::{
+        intenal_executable::InternalExecutable,
+        internal_executable_definition::InternalExecutableDefinition,
+    },
+    logger::logger::Logger,
+};
+
+pub struct Help;
+
+impl Help {
+    pub fn list_all(
+        root_commands: &HashMap<String, Command>,
+        internals: &HashMap<String, Box<dyn InternalExecutable>>,
+        externals: &HashMap<String, RepoKitCommand>,
+    ) {
+        Help::log_internal_commands(internals);
+        Help::log_root_commands(root_commands);
+        Help::log_external_commands(externals);
+    }
+
+    pub fn log_internal_command(command: &InternalExecutableDefinition) {
+        println!(
+            "{}{} {}",
+            Logger::indent(Some(3)),
+            Logger::blue_bright(command.name),
+            Logger::gray(command.description),
+        );
+        Help::print_args(&command.args);
+    }
+
+    pub fn log_root_command(command: &ParsedCommand) {
+        println!(
+            "{}{} {}",
+            Logger::indent(Some(3)),
+            Logger::blue(&command.name),
+            Logger::gray(&command.description),
+        );
+    }
+
+    pub fn log_external_command(command: &RepoKitCommand) {
+        println!(
+            "{}{} {}",
+            Logger::indent(Some(3)),
+            Logger::blue_bright(&command.name),
+            Logger::gray(&command.description),
+        );
+        Help::print_commands(&command.commands, Some(6));
+        if !command.owner.is_empty() {
+            println!(
+                "\n{}{}{}",
+                Logger::indent(Some(9)),
+                Logger::gray("Owned by: "),
+                Logger::cyan(&command.owner),
+            );
+        }
+    }
+
+    pub fn print_commands(map: &HashMap<String, Command>, indentation: Option<i32>) {
+        for (name, command) in map {
+            println!(
+                "{}{}{}",
+                Logger::indent(indentation),
+                Logger::green(format!("{}: ", name).as_str()),
+                Logger::gray(&command.description),
+            );
+        }
+    }
+
+    pub fn log_internal_commands(internals: &HashMap<String, Box<dyn InternalExecutable>>) {
+        if internals.is_empty() {
+            return;
+        }
+        let sorted_internals = Help::sort_internal(internals);
+        Logger::space_around("Internal Commands:");
+        for internal in sorted_internals {
+            Help::log_internal_command(internal.get_definition());
+            println!();
+        }
+    }
+
+    pub fn log_root_commands(root_commands: &HashMap<String, Command>) {
+        if root_commands.is_empty() {
+            return;
+        }
+        let sorted_commands = Help::sort_root_commands(root_commands);
+        Logger::info("Project Level Commands:");
+        println!();
+        for command in sorted_commands {
+            Help::log_root_command(&command);
+        }
+        println!();
+    }
+
+    pub fn log_external_commands(externals: &HashMap<String, RepoKitCommand>) {
+        if externals.is_empty() {
+            return;
+        }
+        let sorted_externals = Help::sort_external(externals);
+        Logger::info("Registered Commands:");
+        println!();
+        for external in sorted_externals {
+            Help::log_external_command(external);
+            println!();
+        }
+    }
+
+    fn print_args(map: &HashMap<&'static str, &'static str>) {
+        for (name, description) in map {
+            println!(
+                "{}{}{}",
+                Logger::indent(Some(6)),
+                Logger::green(format!("{}: ", name).as_str()),
+                Logger::gray(description),
+            );
+        }
+    }
+
+    fn sort_internal(
+        commands: &HashMap<String, Box<dyn InternalExecutable>>,
+    ) -> Vec<&Box<dyn InternalExecutable>> {
+        let mut vector: Vec<&Box<dyn InternalExecutable>> = commands.values().collect();
+        sort_slice_by_str_key(&mut vector, |x| &x.get_definition().name);
+        vector
+    }
+
+    fn sort_external(commands: &HashMap<String, RepoKitCommand>) -> Vec<&RepoKitCommand> {
+        let mut vector: Vec<&RepoKitCommand> = (commands).values().collect();
+        sort_slice_by_str_key(&mut vector, |x| &x.name);
+        vector
+    }
+
+    fn sort_root_commands(commands: &HashMap<String, Command>) -> Vec<ParsedCommand> {
+        let mut vector: Vec<&String> = (commands).keys().collect();
+        sort_str_slice(&mut vector);
+        vector
+            .iter()
+            .map(|&name| ParsedCommand::from(name, commands.get(name).expect("known keys only")))
+            .collect()
+    }
+}

package/workspaces/internal_commands/internal_registry.rs

@@ -0,0 +1,59 @@
+use std::collections::HashMap;
+
+use crate::{
+    executables::intenal_executable::InternalExecutable,
+    internal_commands::{
+        list_commands::ListCommands, list_owners::ListOwners, locate_command::LocateCommand,
+        onboarder::Onboarder, register_command::RegisterCommand, search_commands::SearchCommands,
+        upgrade_repokit::UpgradeRepoKit,
+    },
+    repokit::interfaces::RepoKitConfig,
+};
+
+pub struct InternalRegistry {
+    root: String,
+    configuration: RepoKitConfig,
+}
+
+impl InternalRegistry {
+    pub fn new(root: String, configuration: RepoKitConfig) -> InternalRegistry {
+        InternalRegistry {
+            root,
+            configuration,
+        }
+    }
+
+    pub fn get_all(&self) -> HashMap<String, Box<dyn InternalExecutable>> {
+        let internals: [Box<dyn InternalExecutable>; 7] = [
+            Box::new(Onboarder::new(
+                self.root.clone(),
+                self.configuration.clone(),
+            )),
+            Box::new(ListCommands::new(
+                self.root.clone(),
+                self.configuration.clone(),
+            )),
+            Box::new(SearchCommands::new(
+                self.root.clone(),
+                self.configuration.clone(),
+            )),
+            Box::new(ListOwners::new(
+                self.root.clone(),
+                self.configuration.clone(),
+            )),
+            Box::new(LocateCommand::new(
+                self.root.clone(),
+                self.configuration.clone(),
+            )),
+            Box::new(RegisterCommand::new(
+                self.root.clone(),
+                self.configuration.clone(),
+            )),
+            Box::new(UpgradeRepoKit::new(
+                self.root.clone(),
+                self.configuration.clone(),
+            )),
+        ];
+        HashMap::from(internals.map(|x| (x.get_definition().name.to_string(), x)))
+    }
+}

package/workspaces/internal_commands/list_commands.rs

@@ -0,0 +1,106 @@
+use std::collections::HashMap;
+
+use crate::{
+    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
+    executables::{
+        intenal_executable::InternalExecutable,
+        internal_executable_definition::InternalExecutableDefinition,
+    },
+    internal_commands::help::Help,
+    logger::logger::Logger,
+    validations::command_validations::CommandValidations,
+};
+
+pub struct ListCommands {
+    pub root: String,
+    pub configuration: RepoKitConfig,
+    pub definition: InternalExecutableDefinition,
+}
+
+static SCOPES: [&str; 4] = ["internal", "registered", "root", "<owner>"];
+
+impl ListCommands {
+    pub fn new(root: String, configuration: RepoKitConfig) -> ListCommands {
+        ListCommands {
+            root,
+            configuration,
+            definition: InternalExecutableDefinition {
+                name: "list",
+                description: "List commands based on their scope of definition",
+                args: HashMap::from([(
+                    "<scope>",
+                    format!(
+                        "The scope of the commands you wish to list. Specify one of {}",
+                        Logger::blue(SCOPES.join(" | ").as_str())
+                    )
+                    .leak() as &'static str,
+                )]),
+            },
+        }
+    }
+
+    fn collect_registered_commands(&self) -> HashMap<String, RepoKitCommand> {
+        let validators = CommandValidations::new(self.root.clone(), self.configuration.clone());
+        validators.collect_and_validate_externals()
+    }
+
+    fn exit_on_invalid_scope(&self) {
+        Logger::exit_with_info(
+            format!(
+                "Please specify a scope to list the commands of. Select one of {}",
+                Logger::blue_bright(SCOPES.join(" | ").as_str())
+            )
+            .as_str(),
+        );
+    }
+}
+
+impl InternalExecutable for ListCommands {
+    fn run(&self, args: Vec<String>, internals: &HashMap<String, Box<dyn InternalExecutable>>) {
+        if args.is_empty() {
+            return self.exit_on_invalid_scope();
+        }
+        let query = args[0].as_str();
+        let scope = &query.to_lowercase();
+        if scope == SCOPES[0] {
+            return Help::log_internal_commands(internals);
+        }
+        if scope == SCOPES[2] {
+            return Help::log_root_commands(&self.configuration.commands);
+        }
+        let registered_commands = self.collect_registered_commands();
+        if scope == SCOPES[1] {
+            return Help::log_external_commands(&registered_commands);
+        }
+        let full_query = args.join(" ");
+        let full_scope = &full_query.to_lowercase();
+        Logger::info("Searching registered commands");
+        let matches: HashMap<String, RepoKitCommand> = registered_commands
+            .iter()
+            .filter_map(|(name, x)| {
+                if x.owner.to_lowercase().contains(full_scope) {
+                    return Some((name.clone(), x.clone()));
+                }
+                None
+            })
+            .collect();
+        if matches.is_empty() {
+            Logger::exit_with_info(
+                format!(
+                    "I could not find any commands matching {}",
+                    Logger::blue_bright(&full_query)
+                )
+                .as_str(),
+            );
+        }
+        Help::log_external_commands(&matches);
+    }
+
+    fn help(&self) {
+        Help::log_internal_command(&self.definition);
+    }
+
+    fn get_definition(&self) -> &InternalExecutableDefinition {
+        &self.definition
+    }
+}

package/workspaces/internal_commands/list_owners.rs

@@ -0,0 +1,74 @@
+use std::collections::{HashMap, HashSet};
+
+use alphanumeric_sort::sort_str_slice;
+
+use crate::{
+    executables::{
+        intenal_executable::InternalExecutable,
+        internal_executable_definition::InternalExecutableDefinition,
+    },
+    internal_commands::help::Help,
+    logger::logger::Logger,
+    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
+    validations::command_validations::CommandValidations,
+};
+
+pub struct ListOwners {
+    pub root: String,
+    pub configuration: RepoKitConfig,
+    pub definition: InternalExecutableDefinition,
+}
+
+impl ListOwners {
+    pub fn new(root: String, configuration: RepoKitConfig) -> ListOwners {
+        ListOwners {
+            root,
+            configuration,
+            definition: InternalExecutableDefinition {
+                name: "owners",
+                description: "Lists all registered command owners",
+                args: HashMap::from([]),
+            },
+        }
+    }
+
+    fn collect_registered_commands(&self) -> HashMap<String, RepoKitCommand> {
+        let validators = CommandValidations::new(self.root.clone(), self.configuration.clone());
+        validators.collect_and_validate_externals()
+    }
+}
+
+impl InternalExecutable for ListOwners {
+    fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
+        let registered_commands = self.collect_registered_commands();
+        Logger::info("Listing all command owners");
+        let mut owners: HashSet<String> = HashSet::new();
+        for (_, command) in registered_commands {
+            if !command.owner.is_empty() {
+                owners.insert(command.owner);
+            }
+        }
+        if owners.is_empty() {
+            return Logger::exit_with_info("No owners found");
+        }
+        println!();
+        let mut list: Vec<String> = owners.into_iter().collect();
+        sort_str_slice(&mut list);
+        for (index, owner) in list.iter().enumerate() {
+            println!(
+                "{}{}",
+                Logger::indent(None),
+                Logger::cyan(format!("{}. {}", index + 1, &owner).as_str()),
+            );
+        }
+        println!();
+    }
+
+    fn help(&self) {
+        Help::log_internal_command(&self.definition);
+    }
+
+    fn get_definition(&self) -> &InternalExecutableDefinition {
+        &self.definition
+    }
+}

package/workspaces/internal_commands/locate_command.rs

@@ -0,0 +1,78 @@
+use ::futures::executor;
+use std::{collections::HashMap, process::exit};
+
+use crate::{
+    repokit::interfaces::RepoKitConfig,
+    executables::{
+        intenal_executable::InternalExecutable,
+        internal_executable_definition::InternalExecutableDefinition,
+    },
+    external_commands::external_commands::ExternalCommands,
+    internal_commands::help::Help,
+    logger::logger::Logger,
+};
+
+pub struct LocateCommand {
+    pub root: String,
+    pub configuration: RepoKitConfig,
+    pub definition: InternalExecutableDefinition,
+}
+
+impl LocateCommand {
+    pub fn new(root: String, configuration: RepoKitConfig) -> LocateCommand {
+        LocateCommand {
+            root,
+            configuration,
+            definition: InternalExecutableDefinition {
+                name: "locate",
+                description: "Locates command definitions",
+                args: HashMap::from([("<name>", "The name of a registered command")]),
+            },
+        }
+    }
+
+    fn search_externals(&self, query: &str) {
+        let finder = ExternalCommands::new(self.root.clone());
+        let commands = executor::block_on(finder.find_all());
+        for command in commands {
+            if command.name == query {
+                Logger::log_file_path(&command.location);
+                exit(0);
+            }
+        }
+    }
+
+    fn search_root(&self, command: &str) {
+        if self.configuration.commands.contains_key(command) {
+            Logger::log_file_path(format!("{}/repokit.ts", &self.root).as_str());
+            exit(0);
+        }
+    }
+}
+
+impl InternalExecutable for LocateCommand {
+    fn run(&self, args: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
+        if args.is_empty() {
+            Logger::exit_with_info("Please specify a command to locate");
+        }
+        let command = &args[0];
+        Logger::info(format!("Locating a command named {}", Logger::blue_bright(command)).as_str());
+        self.search_externals(command);
+        self.search_root(command);
+        Logger::exit_with_error(
+            format!(
+                "I could not find a command named {}",
+                Logger::blue_bright(command)
+            )
+            .as_str(),
+        );
+    }
+
+    fn help(&self) {
+        Help::log_internal_command(&self.definition);
+    }
+
+    fn get_definition(&self) -> &InternalExecutableDefinition {
+        &self.definition
+    }
+}

package/workspaces/internal_commands/mod.rs

@@ -0,0 +1,10 @@
+pub mod help;
+pub mod internal_registry;
+pub mod list_commands;
+pub mod list_owners;
+pub mod locate_command;
+pub mod onboarder;
+pub mod register_command;
+pub mod search_commands;
+pub mod typescript_command;
+pub mod upgrade_repokit;

package/workspaces/internal_commands/onboarder.rs

@@ -0,0 +1,66 @@
+use std::collections::HashMap;
+
+use crate::{
+    executables::{
+        intenal_executable::InternalExecutable,
+        internal_executable_definition::InternalExecutableDefinition,
+    },
+    internal_commands::help::Help,
+    logger::logger::Logger,
+    repokit::interfaces::RepoKitConfig,
+};
+
+pub struct Onboarder {
+    pub root: String,
+    pub configuration: RepoKitConfig,
+    pub definition: InternalExecutableDefinition,
+}
+
+impl Onboarder {
+    pub fn new(root: String, configuration: RepoKitConfig) -> Onboarder {
+        Onboarder {
+            root,
+            configuration,
+            definition: InternalExecutableDefinition {
+                name: "onboard",
+                description: "Onboarding instructions for first time users",
+                args: HashMap::from([]),
+            },
+        }
+    }
+}
+
+impl InternalExecutable for Onboarder {
+    fn run(&self, _: Vec<String>, _: &HashMap<String, Box<dyn InternalExecutable>>) {
+        Logger::info(format!("Welcome to {}", Logger::blue_bright("Repokit")).as_str());
+        Logger::info(
+            "Repokit is a tool designed to self-document and publish developer facing workflows in a single CLI",
+        );
+        Logger::info(
+            format!("As you develop new features in your codebase, you can publish commands, API's, and tools to the {} CLI by running", Logger::blue_bright("Repokit")).as_str()
+        );
+        Logger::log_file_path("repokit register ./path/to/your-feature");
+        Logger::info(
+            "This command creates a tooling definition for your feature in a file collocated to your code",
+        );
+        Logger::info(
+            format!(
+                "The {} CLI will automatically detect these files and add them to its toolchain",
+                Logger::blue_bright("Repokit")
+            )
+            .as_str(),
+        );
+        Logger::info(
+            format!("As your codebase grows, your {} CLI will continue to track all of the published workflows created by your team", Logger::blue_bright("Repokit")).as_str()
+        );
+        Logger::space_around("It's your living source of knowledge and documentation");
+    }
+
+    fn help(&self) {
+        Help::log_internal_command(&self.definition);
+    }
+
+    fn get_definition(&self) -> &InternalExecutableDefinition {
+        &self.definition
+    }
+}