@repokit/core 1.1.0 → 1.3.0

package/externals/RepoKitConfig.ts

@@ -1,10 +1,13 @@
 import type { ICommand, IRepoKitConfig } from "./types";
+import type { RepoKitCommand } from "./RepoKitCommand";
 
 export class RepoKitConfig implements Required<IRepoKitConfig> {
   project: string;
+  thirdParty: RepoKitCommand[];
   commands: Record<string, ICommand>;
-  constructor({ project, commands = {} }: IRepoKitConfig) {
+  constructor({ project, commands = {}, thirdParty = [] }: IRepoKitConfig) {
     this.project = project;
     this.commands = commands;
+    this.thirdParty = thirdParty;
   }
 }

package/externals/types.ts

@@ -1,5 +1,8 @@
+import type { RepoKitCommand } from "./RepoKitCommand";
+
 export interface IRepoKitConfig {
   project: string;
+  thirdParty?: RepoKitCommand[];
   commands?: Record<string, ICommand>;
 }
 

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

@@ -1,5 +1,13 @@
 use std::collections::HashMap;
 
+use crate::repokit::interfaces::RepoKitConfig;
+
+#[derive(Clone)]
+pub struct RepoKitScope {
+    pub root: String,
+    pub configuration: RepoKitConfig,
+}
+
 #[derive(Clone)]
 pub struct InternalExecutableDefinition {
     pub name: String,
@@ -14,7 +22,7 @@ pub struct InternalExecutableDefinitionInput<'a, const N: usize> {
 }
 
 impl InternalExecutableDefinition {
-    pub fn define<'a, const N: usize>(
+    pub fn define<const N: usize>(
         definition: InternalExecutableDefinitionInput<N>,
     ) -> InternalExecutableDefinition {
         let InternalExecutableDefinitionInput {

package/internals/external_commands/external_commands.rs

@@ -17,8 +17,10 @@ pub struct ExternalCommands {
 }
 
 impl ExternalCommands {
-    pub fn new(root: String) -> ExternalCommands {
-        ExternalCommands { root }
+    pub fn new(root: &str) -> ExternalCommands {
+        ExternalCommands {
+            root: root.to_string(),
+        }
     }
 
     pub async fn find_all(&self) -> Vec<RepoKitCommand> {
@@ -64,7 +66,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 {

package/internals/internal_commands/internal_registry.rs

@@ -1,58 +1,36 @@
 use std::collections::HashMap;
 
 use crate::{
-    executables::intenal_executable::InternalExecutable,
+    executables::{
+        intenal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
+    },
     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,
+    scope: RepoKitScope,
 }
 
 impl InternalRegistry {
-    pub fn new(root: String, configuration: RepoKitConfig) -> InternalRegistry {
+    pub fn new(scope: &RepoKitScope) -> InternalRegistry {
         InternalRegistry {
-            root,
-            configuration,
+            scope: scope.clone(),
         }
     }
 
     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(),
-            )),
+            Box::new(Onboarder::new(&self.scope)),
+            Box::new(ListCommands::new(&self.scope)),
+            Box::new(SearchCommands::new(&self.scope)),
+            Box::new(ListOwners::new(&self.scope)),
+            Box::new(LocateCommand::new(&self.scope)),
+            Box::new(RegisterCommand::new(&self.scope)),
+            Box::new(UpgradeRepoKit::new(&self.scope)),
         ];
         HashMap::from(internals.map(|x| (x.get_definition().name.to_string(), x)))
     }

package/internals/internal_commands/list_commands.rs

@@ -4,28 +4,26 @@ use crate::{
     executables::{
         intenal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
+    repokit::interfaces::RepoKitCommand,
     validations::command_validations::CommandValidations,
 };
 
 pub struct ListCommands {
-    pub root: String,
-    pub configuration: RepoKitConfig,
+    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 static SCOPES: [&str; 4] = ["internal", "registered", "root", "<owner>"];
 
 impl ListCommands {
-    pub fn new(root: String, configuration: RepoKitConfig) -> ListCommands {
+    pub fn new(scope: &RepoKitScope) -> ListCommands {
         ListCommands {
-            root,
-            configuration,
+            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "list",
                 description: "List commands based on their scope of definition",
@@ -42,7 +40,7 @@ impl ListCommands {
     }
 
     fn collect_registered_commands(&self) -> HashMap<String, RepoKitCommand> {
-        let validators = CommandValidations::new(self.root.clone(), self.configuration.clone());
+        let validators = CommandValidations::new(&self.scope);
         validators.collect_and_validate_externals()
     }
 
@@ -68,7 +66,7 @@ impl InternalExecutable for ListCommands {
             return Help::log_internal_commands(internals);
         }
         if scope == SCOPES[2] {
-            return Help::log_root_commands(&self.configuration.commands);
+            return Help::log_root_commands(&self.scope.configuration.commands);
         }
         let registered_commands = self.collect_registered_commands();
         if scope == SCOPES[1] {

package/internals/internal_commands/list_owners.rs

@@ -6,26 +6,24 @@ use crate::{
     executables::{
         intenal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::interfaces::{RepoKitCommand, RepoKitConfig},
+    repokit::interfaces::RepoKitCommand,
     validations::command_validations::CommandValidations,
 };
 
 pub struct ListOwners {
-    pub root: String,
-    pub configuration: RepoKitConfig,
+    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl ListOwners {
-    pub fn new(root: String, configuration: RepoKitConfig) -> ListOwners {
+    pub fn new(scope: &RepoKitScope) -> ListOwners {
         ListOwners {
-            root,
-            configuration,
+            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "owners",
                 description: "Lists all registered command owners",
@@ -35,7 +33,7 @@ impl ListOwners {
     }
 
     fn collect_registered_commands(&self) -> HashMap<String, RepoKitCommand> {
-        let validators = CommandValidations::new(self.root.clone(), self.configuration.clone());
+        let validators = CommandValidations::new(&self.scope);
         validators.collect_and_validate_externals()
     }
 }

package/internals/internal_commands/locate_command.rs

@@ -1,30 +1,26 @@
-use ::futures::executor;
 use std::{collections::HashMap, process::exit};
 
 use crate::{
     executables::{
         intenal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
-    external_commands::external_commands::ExternalCommands,
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::interfaces::RepoKitConfig,
+    validations::command_validations::CommandValidations,
 };
 
 pub struct LocateCommand {
-    pub root: String,
-    pub configuration: RepoKitConfig,
+    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl LocateCommand {
-    pub fn new(root: String, configuration: RepoKitConfig) -> LocateCommand {
+    pub fn new(scope: &RepoKitScope) -> LocateCommand {
         LocateCommand {
-            root,
-            configuration,
+            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "locate",
                 description: "Locates command definitions",
@@ -34,9 +30,9 @@ impl LocateCommand {
     }
 
     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 {
+        let finder = CommandValidations::new(&self.scope);
+        let all = finder.collect_and_validate_externals();
+        for (_, command) in all {
             if command.name == query {
                 Logger::log_file_path(&command.location);
                 exit(0);
@@ -45,8 +41,8 @@ impl LocateCommand {
     }
 
     fn search_root(&self, command: &str) {
-        if self.configuration.commands.contains_key(command) {
-            Logger::log_file_path(format!("{}/repokit.ts", &self.root).as_str());
+        if self.scope.configuration.commands.contains_key(command) {
+            Logger::log_file_path(format!("{}/repokit.ts", &self.scope.root).as_str());
             exit(0);
         }
     }

package/internals/internal_commands/onboarder.rs

@@ -4,25 +4,22 @@ use crate::{
     executables::{
         intenal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::interfaces::RepoKitConfig,
 };
 
 pub struct Onboarder {
-    pub root: String,
-    pub configuration: RepoKitConfig,
+    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl Onboarder {
-    pub fn new(root: String, configuration: RepoKitConfig) -> Onboarder {
+    pub fn new(scope: &RepoKitScope) -> Onboarder {
         Onboarder {
-            root,
-            configuration,
+            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "onboard",
                 description: "Onboarding instructions for first time users",

package/internals/internal_commands/register_command.rs

@@ -11,26 +11,23 @@ use crate::{
     executables::{
         intenal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     internal_commands::help::Help,
     internal_filesystem::internal_filesystem::InternalFileSystem,
     logger::logger::Logger,
-    repokit::interfaces::RepoKitConfig,
 };
 
 pub struct RegisterCommand {
-    pub root: String,
-    pub configuration: RepoKitConfig,
+    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl RegisterCommand {
-    pub fn new(root: String, configuration: RepoKitConfig) -> RegisterCommand {
+    pub fn new(scope: &RepoKitScope) -> RegisterCommand {
         RegisterCommand {
-            root,
-            configuration,
+            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "register",
                 description: "Creates new Repokit commands",
@@ -50,7 +47,7 @@ impl RegisterCommand {
         if path_arg.is_empty() {
             RegisterCommand::exit_on_missing_path();
         }
-        let path = Path::new(&self.root).join(&path_arg).normalize();
+        let path = Path::new(&self.scope.root).join(&path_arg).normalize();
         if !path.exists() {
             Logger::info(
                 format!(
@@ -93,7 +90,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.scope.root).resolve_template("command_template.ts");
         let mut source = File::open(template_path).expect("Template");
         let mut target = File::create(&command_path).expect("creating");
         io::copy(&mut source, &mut target).expect("writing");

package/internals/internal_commands/search_commands.rs

@@ -5,26 +5,24 @@ use crate::{
     executables::{
         intenal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::interfaces::{CommandDefinition, RepoKitCommand, RepoKitConfig},
+    repokit::interfaces::{CommandDefinition, RepoKitCommand},
     validations::command_validations::CommandValidations,
 };
 
 pub struct SearchCommands {
-    pub root: String,
-    pub configuration: RepoKitConfig,
+    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl SearchCommands {
-    pub fn new(root: String, configuration: RepoKitConfig) -> SearchCommands {
+    pub fn new(scope: &RepoKitScope) -> SearchCommands {
         SearchCommands {
-            root,
-            configuration,
+            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "search",
                 description: "Retrieve commands that match any search query",
@@ -46,8 +44,7 @@ impl SearchCommands {
         }
         if let Some(args) = &config.args {
             for (arg, description) in args {
-                if arg.to_lowercase().contains(query)
-                    || description.to_lowercase().contains(query)
+                if arg.to_lowercase().contains(query) || description.to_lowercase().contains(query)
                 {
                     return true;
                 }
@@ -66,7 +63,7 @@ impl SearchCommands {
         }
         if command
             .location
-            .replace(self.root.as_str(), "")
+            .replace(self.scope.root.as_str(), "")
             .to_lowercase()
             .contains(query)
         {
@@ -158,12 +155,11 @@ impl InternalExecutable for SearchCommands {
             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 externals = CommandValidations::new(&self.scope).collect_and_validate_externals();
         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 {
+        for (command, script) in &self.scope.configuration.commands {
             if self.search_command(&query, script) {
                 root_results.insert(command.clone(), script.clone());
             }

package/internals/internal_commands/typescript_command.rs

@@ -14,24 +14,26 @@ 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);
         }
-        let RepoKitConfig { project, commands } =
-            from_str(stdout.as_str()).expect("Error parsing stdout");
-        RepoKitConfig { project, commands }
+        let config: RepoKitConfig = from_str(stdout.as_str()).unwrap();
+        config
     }
 
     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

@@ -5,26 +5,23 @@ use crate::{
     executables::{
         intenal_executable::InternalExecutable,
         internal_executable_definition::{
-            InternalExecutableDefinition, InternalExecutableDefinitionInput,
+            InternalExecutableDefinition, InternalExecutableDefinitionInput, RepoKitScope,
         },
     },
     executor::executor::Executor,
     internal_commands::help::Help,
     logger::logger::Logger,
-    repokit::interfaces::RepoKitConfig,
 };
 
 pub struct UpgradeRepoKit {
-    pub root: String,
-    pub configuration: RepoKitConfig,
+    pub scope: RepoKitScope,
     pub definition: InternalExecutableDefinition,
 }
 
 impl UpgradeRepoKit {
-    pub fn new(root: String, configuration: RepoKitConfig) -> UpgradeRepoKit {
+    pub fn new(scope: &RepoKitScope) -> UpgradeRepoKit {
         UpgradeRepoKit {
-            root,
-            configuration,
+            scope: scope.clone(),
             definition: InternalExecutableDefinition::define(InternalExecutableDefinitionInput {
                 name: "upgrade",
                 description: "Upgrades your installation of repokit to the latest stable version",
@@ -41,7 +38,7 @@ impl UpgradeRepoKit {
             ("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();
+            let path = Path::new(&self.scope.root).join(lock_file).normalize();
             if path.exists() && path.is_file() {
                 Logger::info(
                     format!("Detected {} installation", Logger::blue_bright(manager)).as_str(),
@@ -63,7 +60,7 @@ impl InternalExecutable for UpgradeRepoKit {
         let command_prefix = self.get_package_manager();
         Executor::exec(
             format!("{} @repokit/core@latest", command_prefix).as_str(),
-            |cmd| cmd.current_dir(&self.root),
+            |cmd| cmd.current_dir(&self.scope.root),
         );
         Logger::info("Upgrade complete!");
     }

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/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

@@ -31,13 +31,19 @@ impl RootCommand {
 #[derive(Debug, Deserialize, Clone)]
 pub struct RepoKitConfig {
     pub project: String,
+    pub thirdParty: Vec<RepoKitCommand>,
     pub commands: HashMap<String, CommandDefinition>,
 }
 
+fn registered_as_plugin() -> String {
+    "This command is registered in your devkit.ts file".to_string()
+}
+
 #[derive(Debug, Deserialize, Clone)]
 pub struct RepoKitCommand {
     pub name: String,
     pub owner: String,
+    #[serde(default = "registered_as_plugin")]
     pub location: String,
     pub description: String,
     pub commands: HashMap<String, CommandDefinition>,

package/internals/repokit/repokit.rs

@@ -6,7 +6,9 @@ use std::{
 };
 
 use crate::{
-    executables::intenal_executable::InternalExecutable,
+    executables::{
+        intenal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
+    },
     executor::executor::Executor,
     internal_commands::help::Help,
     logger::logger::Logger,
@@ -15,16 +17,17 @@ use crate::{
 };
 
 pub struct RepoKit {
-    pub root: String,
-    pub configuration: RepoKitConfig,
+    pub scope: RepoKitScope,
 }
 
 impl RepoKit {
     pub fn new(root: String, configuration: RepoKitConfig) -> RepoKit {
         Logger::set_name(&configuration.project);
         RepoKit {
-            root,
-            configuration,
+            scope: RepoKitScope {
+                root,
+                configuration,
+            },
         }
     }
 
@@ -36,11 +39,16 @@ impl RepoKit {
             let interface = internals.get(&command).expect("exists");
             return interface.run(args, &internals);
         }
-        if self.configuration.commands.contains_key(&command) {
-            let root_script = self.configuration.commands.get(&command).expect("exists");
+        if self.scope.configuration.commands.contains_key(&command) {
+            let root_script = self
+                .scope
+                .configuration
+                .commands
+                .get(&command)
+                .expect("exists");
             return Executor::with_stdio(
                 format!("{} {}", root_script.command, &args.join(" ")),
-                |cmd| cmd.current_dir(Path::new(&self.root)),
+                |cmd| cmd.current_dir(Path::new(&self.scope.root)),
             );
         }
         let externals = validator.collect_and_validate_externals();
@@ -70,7 +78,7 @@ impl RepoKit {
         let argv: Vec<String> = args().collect();
         if argv.len() < 2 {
             let (internals, externals) = self.collect_and_validate();
-            Help::list_all(&self.configuration.commands, &internals, &externals);
+            Help::list_all(&self.scope.configuration.commands, &internals, &externals);
             process::exit(0);
         }
         let command = &argv[1];
@@ -99,7 +107,7 @@ impl RepoKit {
         internals: &HashMap<String, Box<dyn InternalExecutable>>,
         externals: &HashMap<String, RepoKitCommand>,
     ) {
-        Help::list_all(&self.configuration.commands, internals, externals);
+        Help::list_all(&self.scope.configuration.commands, internals, externals);
         Logger::info(
             format!(
                 "I'm not aware of a command named {}",

package/internals/validations/command_validations.rs

@@ -3,47 +3,43 @@ use std::collections::HashMap;
 use futures::executor;
 
 use crate::{
-    repokit::{
-        repokit::RepoKit,
-        interfaces::{RepoKitCommand, RepoKitConfig},
+    executables::{
+        intenal_executable::InternalExecutable, internal_executable_definition::RepoKitScope,
     },
-    executables::intenal_executable::InternalExecutable,
     external_commands::external_commands::ExternalCommands,
     internal_commands::internal_registry::InternalRegistry,
     logger::logger::Logger,
+    repokit::{interfaces::RepoKitCommand, repokit::RepoKit},
 };
 
 pub struct CommandValidations {
-    root: String,
-    configuration: RepoKitConfig,
+    scope: RepoKitScope,
 }
 
 impl CommandValidations {
-    pub fn new(root: String, configuration: RepoKitConfig) -> CommandValidations {
+    pub fn new(scope: &RepoKitScope) -> CommandValidations {
         CommandValidations {
-            root,
-            configuration,
+            scope: scope.clone(),
         }
     }
 
     pub fn from(kit: &RepoKit) -> CommandValidations {
         CommandValidations {
-            root: kit.root.clone(),
-            configuration: kit.configuration.clone(),
+            scope: kit.scope.clone(),
         }
     }
 
     pub fn collect_and_validate_internals(&self) -> HashMap<String, Box<dyn InternalExecutable>> {
-        let internals =
-            InternalRegistry::new(self.root.clone(), self.configuration.clone()).get_all();
+        let internals = InternalRegistry::new(&self.scope).get_all();
         self.detect_collisions_between_internals_and_root_commands(&internals);
         internals
     }
 
     pub fn collect_and_validate_externals(&self) -> HashMap<String, RepoKitCommand> {
-        let finder = ExternalCommands::new(self.root.clone());
+        let finder = ExternalCommands::new(&self.scope.root);
         let externals = executor::block_on(finder.find_all());
-        self.detect_collisions_between_root_commands_and_externals(&externals)
+        let all = [&externals[..], &self.scope.configuration.thirdParty[..]].concat();
+        self.detect_collisions_between_root_commands_and_externals(&all)
     }
 
     pub fn detect_collisions_between_internals_and_externals(
@@ -71,7 +67,7 @@ impl CommandValidations {
         internals: &HashMap<String, Box<dyn InternalExecutable>>,
     ) {
         for name in internals.keys() {
-            if self.configuration.commands.contains_key(name) {
+            if self.scope.configuration.commands.contains_key(name) {
                 Logger::info(
                     format!(
                         "I encountered a command named {} in your {} file that conflicts with one of my internals",
@@ -96,7 +92,12 @@ impl CommandValidations {
                 self.on_external_duplicate_collision(command, &original.location);
             }
             map.insert(command.name.clone(), command.clone());
-            if self.configuration.commands.contains_key(&command.name) {
+            if self
+                .scope
+                .configuration
+                .commands
+                .contains_key(&command.name)
+            {
                 self.on_external_root_collision(command);
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "1.1.0",
+  "version": "1.3.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",
-    "repokit": "yarn install:repokit && repokit",
-    "run:dev": "cargo run --package repokit --bin repokit"
+    "postinstall": "yarn grant:exec && ./installation/install.sh",
+    "repokit": "yarn install:rust && 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",