@repokit/core 0.1.1 → 0.1.2

package/install.sh

@@ -16,23 +16,6 @@ else
     curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
 fi
 
-if npm list --depth=0 tsx; then
-    echo "Found tsx installation"
-else
-    # Node Dependencies installation
-    if [ -f "${REPO_ROOT}/yarn.lock" ]; then
-        yarn add -D tsx
-    elif [ -f "${REPO_ROOT}/pnpm-lock.yaml" ]; then
-        pnpm add -D tsx
-    elif [ -f "${REPO_ROOT}/package-lock.json" ]; then
-        npm i -D tsx
-    else
-        echo "No node.js package manager detected"
-        echo "Run npm init to create your node.js project"
-    fi
-fi
-
-
 echo "Installing Repokit CLI"
 
 cd "$SCRIPT_ORIGIN"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "homepage": "https://github.com/alexfigliolia/repokit#readme",
   "license": "MIT",

package/workspaces/configuration/configuration.rs

@@ -1,9 +1,4 @@
-use std::{
-    fs::File,
-    io,
-    path::Path,
-    process::exit,
-};
+use std::{fs::File, io, path::Path, process::exit};
 
 use crate::{internal_filesystem::internal_filesystem::InternalFileSystem, logger::logger::Logger};
 
@@ -17,7 +12,7 @@ impl Configuration {
             return;
         }
         Configuration::welcome();
-        let template_path = InternalFileSystem::resolve_template("configuration_template.ts");
+        let template_path = InternalFileSystem::resolve_template("configuration_template");
         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/workspaces/internal_commands/register_command.rs

@@ -91,7 +91,7 @@ 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::resolve_template("command_template");
         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/workspaces/internal_commands/typescript_command.rs

@@ -20,8 +20,8 @@ impl TypescriptCommand {
     }
 
     pub fn parse_configuration(&self) -> RepoKitConfig {
-        let executable = InternalFileSystem::resolve_command("parse_configuration.ts");
-        let stdout = self.with_tsx(format!("{executable} --root {}", &self.root).as_str());
+        let executable = InternalFileSystem::resolve_command("parse_configuration");
+        let stdout = self.exec_with_node(&executable, format!("--root {}", &self.root).as_str());
         Logger::info(&stdout);
         if stdout.is_empty() {
             Configuration::create(&self.root);
@@ -33,15 +33,22 @@ 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 stdout =
-            self.with_tsx(format!("{executable} --paths {paths} --root {}", self.root).as_str());
+        let executable = InternalFileSystem::resolve_command("parse_commands");
+        let stdout = self.exec_with_node(
+            &executable,
+            format!("--paths {paths} --root {}", self.root).as_str(),
+        );
         let commands: Vec<RepoKitCommand> = serde_json::from_str(&stdout).expect("parse");
         commands
     }
 
-    fn with_tsx(&self, args: &str) -> String {
-        Executor::exec(format!("npx tsx {}", args), |cmd| {
+    fn exec_with_node(&self, executable: &str, args: &str) -> String {
+        let driver = if executable.ends_with(".ts") {
+            "npx tsx"
+        } else {
+            "node"
+        };
+        Executor::exec(format!("{driver} {executable} {}", args), |cmd| {
             cmd.current_dir(Path::new(&self.root))
         })
     }

package/workspaces/internal_filesystem/internal_filesystem.rs

@@ -10,32 +10,33 @@ impl InternalFileSystem {
         path.join(segment).normalize()
     }
 
-    pub fn commands_directory() -> PathBuf {
-        InternalFileSystem::source_internal("commands")
+    pub fn resolve_command(file_name: &str) -> String {
+        let (path, extension) = InternalFileSystem::commands_directory();
+        InternalFileSystem::path_buf_to_str(path.join(format!("{file_name}{extension}")))
     }
 
-    pub fn templates_directory() -> PathBuf {
-        InternalFileSystem::source_internal("templates")
+    pub fn resolve_template(file_name: &str) -> String {
+        let (path, extension) = InternalFileSystem::templates_directory();
+        InternalFileSystem::path_buf_to_str(path.join(format!("{file_name}{extension}")))
     }
 
-    pub fn resolve_command(file_name: &str) -> String {
-        InternalFileSystem::path_buf_to_str(
-            InternalFileSystem::commands_directory().join(file_name),
-        )
+    fn commands_directory() -> (PathBuf, String) {
+        InternalFileSystem::source_internal("commands")
     }
 
-    pub fn resolve_template(file_name: &str) -> String {
-        InternalFileSystem::path_buf_to_str(
-            InternalFileSystem::templates_directory().join(file_name),
-        )
+    fn templates_directory() -> (PathBuf, String) {
+        InternalFileSystem::source_internal("templates")
     }
 
-    fn source_internal(path: &str) -> PathBuf {
+    fn source_internal(path: &str) -> (PathBuf, String) {
         let src = InternalFileSystem::absolute(format!("./src/{path}").as_str());
         if InternalFileSystem::is_in_node_modules(&src) {
-            return InternalFileSystem::absolute(format!("./dist/mjs/{path}").as_str());
+            return (
+                InternalFileSystem::absolute(format!("./dist/mjs/{path}").as_str()),
+                ".js".to_string(),
+            );
         }
-        src
+        (src, ".ts".to_string())
     }
 
     fn path_buf_to_str(buffer: PathBuf) -> String {