@repokit/core 1.0.5 → 1.2.0

package/externals/types.ts

@@ -13,6 +13,7 @@ export interface IRepoKitCommand {
 export interface ICommand {
   command: string;
   description: string;
+  args?: Record<string, string>;
 }
 
 export interface ILocatedCommand extends IRepoKitCommand {

package/{install.sh → installation/install.sh}

@@ -6,7 +6,7 @@ REPO_ROOT=$(git rev-parse --show-toplevel)
 cd $REPO_ROOT
 
 command_exists() {
-    command -v "$1"
+    command -v "$1" > /dev/null 2>&1
 }
 
 if command_exists rustc && command_exists cargo; then

package/internals/configuration/configuration.rs

@@ -12,7 +12,8 @@ impl Configuration {
             return;
         }
         Configuration::welcome();
-        let template_path = InternalFileSystem::resolve_template("configuration_template.ts");
+        let template_path =
+            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");

package/internals/executables/internal_executable_definition.rs

@@ -2,7 +2,39 @@ use std::collections::HashMap;
 
 #[derive(Clone)]
 pub struct InternalExecutableDefinition {
-    pub name: &'static str,
-    pub description: &'static str,
-    pub args: HashMap<&'static str, &'static str>,
+    pub name: String,
+    pub description: String,
+    pub args: Option<HashMap<String, String>>,
+}
+
+pub struct InternalExecutableDefinitionInput<'a, const N: usize> {
+    pub name: &'a str,
+    pub description: &'a str,
+    pub args: [(&'a str, &'a str); N],
+}
+
+impl InternalExecutableDefinition {
+    pub fn define<'a, const N: usize>(
+        definition: InternalExecutableDefinitionInput<N>,
+    ) -> InternalExecutableDefinition {
+        let InternalExecutableDefinitionInput {
+            name,
+            description,
+            args,
+        } = definition;
+        InternalExecutableDefinition {
+            name: String::from(name),
+            description: String::from(description),
+            args: InternalExecutableDefinition::args(args),
+        }
+    }
+
+    pub fn args<const N: usize>(tuples: [(&str, &str); N]) -> Option<HashMap<String, String>> {
+        if tuples.is_empty() {
+            return None;
+        }
+        Some(HashMap::from(tuples.map(|(key, value)| {
+            (String::from(key), String::from(value))
+        })))
+    }
 }

package/internals/external_commands/external_commands.rs

@@ -64,7 +64,7 @@ impl ExternalCommands {
             }
         }
         pool.pool.shutdown_background();
-        TypescriptCommand::new(self.root.clone()).parse_commands(paths)
+        TypescriptCommand::new(&self.root).parse_commands(paths)
     }
 
     fn read(path: &Path) -> bool {
@@ -72,7 +72,7 @@ impl ExternalCommands {
         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(") {
+            if line.ends_with("\"@repokit/core\";") {
                 return true;
             }
         }

package/internals/internal_commands/help.rs

@@ -3,19 +3,19 @@ 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,
+    repokit::interfaces::{CommandDefinition, RepoKitCommand, RootCommand},
 };
 
 pub struct Help;
 
 impl Help {
     pub fn list_all(
-        root_commands: &HashMap<String, Command>,
+        root_commands: &HashMap<String, CommandDefinition>,
         internals: &HashMap<String, Box<dyn InternalExecutable>>,
         externals: &HashMap<String, RepoKitCommand>,
     ) {
@@ -28,29 +28,31 @@ impl Help {
         println!(
             "{}{} {}",
             Logger::indent(Some(3)),
-            Logger::blue_bright(command.name),
-            Logger::gray(command.description),
+            Logger::blue(&command.name),
+            Logger::gray(&command.description),
         );
-        Help::print_args(&command.args);
+        Help::log_args(&command.args, None);
     }
 
-    pub fn log_root_command(command: &ParsedCommand) {
+    pub fn log_root_command(command: &RootCommand) {
         println!(
             "{}{} {}",
             Logger::indent(Some(3)),
             Logger::blue(&command.name),
             Logger::gray(&command.description),
         );
+        Help::log_args(&command.args, None)
     }
 
     pub fn log_external_command(command: &RepoKitCommand) {
         println!(
             "{}{} {}",
             Logger::indent(Some(3)),
-            Logger::blue_bright(&command.name),
+            Logger::blue(&command.name),
             Logger::gray(&command.description),
         );
-        Help::print_commands(&command.commands, Some(6));
+        println!();
+        Help::log_external_subcommands(&command.commands, 6);
         if !command.owner.is_empty() {
             println!(
                 "\n{}{}{}",
@@ -61,14 +63,15 @@ impl Help {
         }
     }
 
-    pub fn print_commands(map: &HashMap<String, Command>, indentation: Option<i32>) {
+    pub fn log_external_subcommands(map: &HashMap<String, CommandDefinition>, indentation: i32) {
         for (name, command) in map {
             println!(
                 "{}{}{}",
-                Logger::indent(indentation),
-                Logger::green(format!("{}: ", name).as_str()),
+                Logger::indent(Some(indentation)),
+                Logger::lime(format!("{}: ", name).as_str()),
                 Logger::gray(&command.description),
             );
+            Help::log_args(&command.args, Some(indentation + 3));
         }
     }
 
@@ -84,7 +87,7 @@ impl Help {
         }
     }
 
-    pub fn log_root_commands(root_commands: &HashMap<String, Command>) {
+    pub fn log_root_commands(root_commands: &HashMap<String, CommandDefinition>) {
         if root_commands.is_empty() {
             return;
         }
@@ -110,14 +113,16 @@ impl Help {
         }
     }
 
-    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 log_args(map: &Option<HashMap<String, String>>, indentation: Option<i32>) {
+        if let Some(args) = map {
+            for (name, description) in args {
+                println!(
+                    "{}{}{}",
+                    Logger::indent(Some(indentation.unwrap_or(6))),
+                    Logger::green(name.as_str()),
+                    Logger::gray(format!(": {}", description).as_str()),
+                );
+            }
         }
     }
 
@@ -135,12 +140,12 @@ impl Help {
         vector
     }
 
-    fn sort_root_commands(commands: &HashMap<String, Command>) -> Vec<ParsedCommand> {
+    fn sort_root_commands(commands: &HashMap<String, CommandDefinition>) -> Vec<RootCommand> {
         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")))
+            .map(|&name| RootCommand::from(name, commands.get(name).expect("known keys only")))
             .collect()
     }
 }

package/internals/internal_commands/list_commands.rs

@@ -1,13 +1,15 @@
 use std::collections::HashMap;
 
 use crate::{
-    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
+    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
     validations::command_validations::CommandValidations,
 };
 
@@ -24,18 +26,18 @@ impl ListCommands {
         ListCommands {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "list",
                 description: "List commands based on their scope of definition",
-                args: HashMap::from([(
+                args: [(
                     "<scope>",
                     format!(
                         "The scope of the commands you wish to list. Specify one of {}",
                         Logger::blue(SCOPES.join(" | ").as_str())
                     )
-                    .leak() as &'static str,
-                )]),
-            },
+                    .as_str(),
+                )],
+            }),
         }
     }
 

package/internals/internal_commands/list_owners.rs

@@ -5,7 +5,9 @@ use alphanumeric_sort::sort_str_slice;
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
@@ -24,11 +26,11 @@ impl ListOwners {
         ListOwners {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "owners",
                 description: "Lists all registered command owners",
-                args: HashMap::from([]),
-            },
+                args: [],
+            }),
         }
     }
 

package/internals/internal_commands/locate_command.rs

@@ -4,7 +4,9 @@ use std::{collections::HashMap, process::exit};
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     external_commands::external_commands::ExternalCommands,
     internal_commands::help::Help,
@@ -23,11 +25,11 @@ impl LocateCommand {
         LocateCommand {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "locate",
                 description: "Locates command definitions",
-                args: HashMap::from([("<name>", "The name of a registered command")]),
-            },
+                args: [("<name>", "The name of a registered command")],
+            }),
         }
     }
 

package/internals/internal_commands/onboarder.rs

@@ -3,7 +3,9 @@ use std::collections::HashMap;
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
@@ -21,11 +23,11 @@ impl Onboarder {
         Onboarder {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "onboard",
                 description: "Onboarding instructions for first time users",
-                args: HashMap::from([]),
-            },
+                args: [],
+            }),
         }
     }
 }

package/internals/internal_commands/register_command.rs

@@ -10,7 +10,9 @@ use std::{
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     internal_filesystem::internal_filesystem::InternalFileSystem,
@@ -29,14 +31,14 @@ impl RegisterCommand {
         RegisterCommand {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "register",
                 description: "Creates new Repokit commands",
-                args: HashMap::from([(
+                args: [(
                     "<path>",
                     "A relative path to your preferred command location",
-                )]),
-            },
+                )],
+            }),
         }
     }
 
@@ -91,7 +93,8 @@ 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 = InternalFileSystem::resolve_template("command_template.ts");
+        let template_path =
+            InternalFileSystem::new(&self.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");

package/internals/internal_commands/search_commands.rs

@@ -2,13 +2,15 @@ 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_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
+    repokit::interfaces::{CommandDefinition, RepoKitCommand, RepoKitConfig},
     validations::command_validations::CommandValidations,
 };
 
@@ -23,14 +25,14 @@ impl SearchCommands {
         SearchCommands {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "search",
                 description: "Retrieve commands that match any search query",
-                args: HashMap::from([(
+                args: [(
                     "<query>",
                     "A search string to match against command names, descriptions, arguments, or owner",
-                )]),
-            },
+                )],
+            }),
         }
     }
 
@@ -42,11 +44,16 @@ impl SearchCommands {
         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;
+        if let Some(args) = &config.args {
+            for (arg, description) in args {
+                if arg.to_lowercase().contains(query)
+                    || description.to_lowercase().contains(query)
+                {
+                    return true;
+                }
             }
         }
+
         false
     }
 
@@ -76,7 +83,7 @@ impl SearchCommands {
         false
     }
 
-    fn search_command(&self, query: &str, command: &Command) -> bool {
+    fn search_command(&self, query: &str, command: &CommandDefinition) -> bool {
         if command.command.to_lowercase().contains(query)
             || command.description.to_lowercase().contains(query)
         {
@@ -85,7 +92,7 @@ impl SearchCommands {
         false
     }
 
-    fn log_root_results(&self, root_results: &HashMap<String, Command>) {
+    fn log_root_results(&self, root_results: &HashMap<String, CommandDefinition>) {
         let total = root_results.len();
         let plural_appendage = if total == 1 { "" } else { "s" };
         if !root_results.is_empty() {
@@ -153,7 +160,7 @@ impl InternalExecutable for SearchCommands {
         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 root_results: HashMap<String, CommandDefinition> = 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 {

package/internals/internal_commands/typescript_command.rs

@@ -14,12 +14,15 @@ pub struct TypescriptCommand {
 }
 
 impl TypescriptCommand {
-    pub fn new(root: String) -> TypescriptCommand {
-        TypescriptCommand { root }
+    pub fn new(root: &str) -> TypescriptCommand {
+        TypescriptCommand {
+            root: root.to_string(),
+        }
     }
 
     pub fn parse_configuration(&self) -> RepoKitConfig {
-        let executable = InternalFileSystem::resolve_command("parse_configuration.ts");
+        let executable =
+            InternalFileSystem::new(&self.root).resolve_command("parse_configuration.ts");
         let stdout = self.execute(format!("{executable} --root {}", &self.root).as_str());
         if stdout.is_empty() {
             Configuration::create(&self.root);
@@ -31,7 +34,7 @@ impl TypescriptCommand {
 
     pub fn parse_commands(&self, path_list: Vec<String>) -> Vec<RepoKitCommand> {
         let paths = path_list.join(",");
-        let executable = InternalFileSystem::resolve_command("parse_commands.ts");
+        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");

package/internals/internal_commands/upgrade_repokit.rs

@@ -4,7 +4,9 @@ use std::{collections::HashMap, path::Path, process::exit};
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
-        internal_executable_definition::InternalExecutableDefinition,
+        internal_executable_definition::{
+            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+        },
     },
     executor::executor::Executor,
     internal_commands::help::Help,
@@ -23,11 +25,11 @@ impl UpgradeRepoKit {
         UpgradeRepoKit {
             root,
             configuration,
-            definition: InternalExecutableDefinition {
+            definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "upgrade",
                 description: "Upgrades your installation of repokit to the latest stable version",
-                args: HashMap::from([]),
-            },
+                args: [],
+            }),
         }
     }
 

package/internals/internal_filesystem/internal_filesystem.rs

@@ -1,36 +1,47 @@
 use normalize_path::NormalizePath;
 use std::path::{Path, PathBuf};
 
-pub struct InternalFileSystem;
+pub struct InternalFileSystem {
+    root: String,
+}
 
 impl InternalFileSystem {
-    pub fn absolute(segment: &str) -> PathBuf {
-        let origin = env!("CARGO_MANIFEST_DIR");
-        let path = Path::new(origin);
+    pub fn new(root: &str) -> InternalFileSystem {
+        InternalFileSystem {
+            root: root.to_string(),
+        }
+    }
+
+    pub fn absolute(&self, segment: &str) -> PathBuf {
+        let path = Path::new(&self.root);
         path.join(segment).normalize()
     }
 
-    pub fn resolve_command(file_name: &str) -> String {
-        InternalFileSystem::path_buf_to_str(
-            InternalFileSystem::commands_directory().join(file_name),
-        )
+    pub fn resolve_command(&self, file_name: &str) -> String {
+        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))
+    }
+
+    fn commands_directory(&self) -> PathBuf {
+        self.absolute(format!("{}/commands", self.package_directory()).as_str())
     }
 
-    pub fn resolve_template(file_name: &str) -> String {
-        InternalFileSystem::path_buf_to_str(
-            InternalFileSystem::templates_directory().join(file_name),
-        )
+    fn templates_directory(&self) -> PathBuf {
+        self.absolute(format!("{}/templates", self.package_directory()).as_str())
     }
 
-    fn commands_directory() -> PathBuf {
-        InternalFileSystem::absolute("./externals/commands")
+    fn package_directory(&self) -> String {
+        format!("./node_modules/{}/externals", self.package_name())
     }
 
-    fn templates_directory() -> PathBuf {
-        InternalFileSystem::absolute("./externals/templates")
+    fn package_name(&self) -> String {
+        "@repokit/core".to_string()
     }
 
-    fn path_buf_to_str(buffer: PathBuf) -> String {
+    fn path_buf_to_str(&self, buffer: PathBuf) -> String {
         buffer
             .into_os_string()
             .into_string()

package/internals/logger/logger.rs

@@ -84,6 +84,14 @@ impl Logger {
         })
     }
 
+    pub fn lime(message: &str) -> ColoredString {
+        message.custom_color(CustomColor {
+            r: 175,
+            g: 247,
+            b: 7,
+        })
+    }
+
     fn info_prefix() -> ColoredString {
         format!("{}: ", *REGISTERED_NAME.lock().unwrap())
             .bright_magenta()

package/internals/main.rs

@@ -15,7 +15,7 @@ mod validations;
 
 fn main() {
     let root = Executor::exec("git rev-parse --show-toplevel", |cmd| cmd);
-    let config = TypescriptCommand::new(root.clone()).parse_configuration();
+    let config = TypescriptCommand::new(&root).parse_configuration();
     let kit = RepoKit::new(root, config);
     kit.invoke();
 }

package/internals/repokit/interfaces.rs

@@ -3,22 +3,25 @@ use std::collections::HashMap;
 use serde::Deserialize;
 
 #[derive(Debug, Deserialize, Clone)]
-pub struct Command {
+pub struct CommandDefinition {
     pub command: String,
     pub description: String,
+    pub args: Option<HashMap<String, String>>,
 }
 
 #[derive(Debug, Deserialize, Clone)]
-pub struct ParsedCommand {
+pub struct RootCommand {
     pub name: String,
     pub command: String,
     pub description: String,
+    pub args: Option<HashMap<String, String>>,
 }
 
-impl ParsedCommand {
-    pub fn from(name: &str, command: &Command) -> ParsedCommand {
-        ParsedCommand {
+impl RootCommand {
+    pub fn from(name: &str, command: &CommandDefinition) -> RootCommand {
+        RootCommand {
             name: name.to_string(),
+            args: command.args.clone(),
             command: command.command.to_string(),
             description: command.description.to_string(),
         }
@@ -28,7 +31,7 @@ impl ParsedCommand {
 #[derive(Debug, Deserialize, Clone)]
 pub struct RepoKitConfig {
     pub project: String,
-    pub commands: HashMap<String, Command>,
+    pub commands: HashMap<String, CommandDefinition>,
 }
 
 #[derive(Debug, Deserialize, Clone)]
@@ -37,5 +40,5 @@ pub struct RepoKitCommand {
     pub owner: String,
     pub location: String,
     pub description: String,
-    pub commands: HashMap<String, Command>,
+    pub commands: HashMap<String, CommandDefinition>,
 }

package/internals/repokit/repokit.rs

@@ -125,17 +125,18 @@ impl RepoKit {
             )
             .as_str(),
         );
-        Help::print_commands(&command.commands, Some(3));
+        Help::log_external_subcommands(&command.commands, 3);
     }
 
     fn log_external_command(&self, command: &RepoKitCommand) {
         Logger::info(
             format!(
-                "Listing available commands for {}",
-                Logger::blue_bright(&command.name)
+                "Listing available commands for {}\n",
+                Logger::blue(&command.name)
             )
             .as_str(),
         );
-        Help::print_commands(&command.commands, Some(3))
+        Help::log_external_subcommands(&command.commands, 3);
+        println!();
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "1.0.5",
+  "version": "1.2.0",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",
@@ -22,12 +22,14 @@
   "scripts": {
     "build:all": "yarn lint:ts && yarn lint:rust && yarn install:rust",
     "build:rust": "cargo build --release",
+    "grant:exec": "chmod -R +x ./installation",
     "install:rust": "yarn build:rust && cargo install --path .",
     "lint:rust": "cargo clippy --fix --allow-dirty",
     "lint:ts": "yarn oxlint --type-aware --type-check --report-unused-disable-directives --fix && yarn oxfmt",
-    "postinstall": "chmod +x ./install.sh && ./install.sh",
+    "postinstall": "yarn grant:exec && ./installation/install.sh",
     "repokit": "yarn install:repokit && repokit",
-    "run:dev": "cargo run --package repokit --bin repokit"
+    "run:dev": "yarn symlink && cargo run --package repokit --bin repokit",
+    "symlink": "yarn grant:exec && ./installation/symlink.sh"
   },
   "dependencies": {
     "@figliolia/event-emitter": "^1.1.6",