@repokit/core 1.3.6 → 1.5.0

package/dist/CommandParser.d.ts

@@ -0,0 +1,6 @@
+import { TSCompiler } from "./TSCompiler";
+export declare class CommandParser extends TSCompiler {
+    static parse(): Promise<void>;
+    private static parseCommand;
+    private static parsePaths;
+}

package/dist/CommandParser.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandParser = void 0;
+const node_util_1 = require("node:util");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+const node_fs_1 = require("node:fs");
+const TSCompiler_1 = require("./TSCompiler");
+const RepoKitCommand_1 = require("./RepoKitCommand");
+/* oxlint-disable typescript-eslint(no-misused-spread) */
+class CommandParser extends TSCompiler_1.TSCompiler {
+    static async parse() {
+        const { paths, root } = this.parsePaths();
+        if (!root || !(0, node_fs_1.existsSync)(root) || !(await (0, promises_1.stat)(root)).isDirectory()) {
+            return console.log(JSON.stringify([]));
+        }
+        const pathList = paths.split(",").filter(Boolean);
+        const results = pathList.map(path => this.parseCommand((0, node_path_1.join)(root, path)));
+        console.log(JSON.stringify(results.flat()));
+    }
+    static parseCommand(path) {
+        const commands = [];
+        const declaredExports = require(path);
+        for (const key in declaredExports) {
+            if (declaredExports[key] instanceof RepoKitCommand_1.RepoKitCommand) {
+                commands.push({ ...declaredExports[key], location: path });
+            }
+        }
+        return commands;
+    }
+    static parsePaths() {
+        try {
+            return (0, node_util_1.parseArgs)({
+                options: {
+                    paths: {
+                        default: "",
+                        multiple: false,
+                        short: "p",
+                        type: "string",
+                    },
+                    root: {
+                        default: "",
+                        multiple: false,
+                        short: "r",
+                        type: "string",
+                    },
+                },
+            }).values;
+        }
+        catch {
+            return { paths: "", root: "" };
+        }
+    }
+}
+exports.CommandParser = CommandParser;

package/dist/ConfigurationParser.d.ts

@@ -0,0 +1,5 @@
+import { TSCompiler } from "./TSCompiler";
+export declare class ConfigurationParser extends TSCompiler {
+    static parse(): void;
+    private static parseRoot;
+}

package/dist/ConfigurationParser.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigurationParser = void 0;
+const node_util_1 = require("node:util");
+const node_path_1 = require("node:path");
+const node_fs_1 = require("node:fs");
+const TSCompiler_1 = require("./TSCompiler");
+const RepoKitConfig_1 = require("./RepoKitConfig");
+class ConfigurationParser extends TSCompiler_1.TSCompiler {
+    static parse() {
+        const root = this.parseRoot();
+        const path = (0, node_path_1.join)(root, "repokit.ts");
+        if (!(0, node_fs_1.existsSync)(path)) {
+            return;
+        }
+        const config = require(path);
+        for (const key in config) {
+            if (config[key] instanceof RepoKitConfig_1.RepoKitConfig) {
+                return console.log(JSON.stringify(config[key].toScoped(path)));
+            }
+        }
+    }
+    static parseRoot() {
+        return (0, node_util_1.parseArgs)({
+            options: {
+                root: {
+                    default: "",
+                    multiple: false,
+                    short: "r",
+                    type: "string",
+                },
+            },
+        }).values.root;
+    }
+}
+exports.ConfigurationParser = ConfigurationParser;

package/dist/RepoKitCommand.d.ts

@@ -0,0 +1,8 @@
+import type { ICommand, IRepoKitCommand } from "./types";
+export declare class RepoKitCommand {
+    name: string;
+    owner: string;
+    description: string;
+    commands: Record<string, ICommand>;
+    constructor({ name, description, owner, commands, }: IRepoKitCommand);
+}

package/dist/RepoKitCommand.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoKitCommand = void 0;
+class RepoKitCommand {
+    name;
+    owner;
+    description;
+    commands;
+    constructor({ name, description, owner = "", commands = {}, }) {
+        this.name = name;
+        this.owner = owner;
+        this.commands = commands;
+        this.description = description;
+    }
+}
+exports.RepoKitCommand = RepoKitCommand;

package/dist/RepoKitConfig.d.ts

@@ -0,0 +1,17 @@
+import type { ICommand, IRepoKitConfig } from "./types";
+import { RepoKitCommand } from "./RepoKitCommand";
+export declare class RepoKitConfig implements Required<IRepoKitConfig> {
+    project: string;
+    thirdParty: RepoKitCommand[];
+    commands: Record<string, ICommand>;
+    constructor({ project, commands, thirdParty }: IRepoKitConfig);
+    toScoped(location: string): this & {
+        thirdParty: {
+            location: string;
+            name: string;
+            owner: string;
+            description: string;
+            commands: Record<string, ICommand>;
+        }[];
+    };
+}

package/dist/RepoKitConfig.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepoKitConfig = void 0;
+const RepoKitCommand_1 = require("./RepoKitCommand");
+/* eslint-disable typescript-eslint(no-misused-spread */
+class RepoKitConfig {
+    project;
+    thirdParty;
+    commands;
+    constructor({ project, commands = {}, thirdParty = [] }) {
+        this.project = project;
+        this.commands = commands;
+        this.thirdParty = thirdParty.map(command => new RepoKitCommand_1.RepoKitCommand(command));
+    }
+    toScoped(location) {
+        return {
+            ...this,
+            thirdParty: this.thirdParty.map(command => ({ ...command, location })),
+        };
+    }
+}
+exports.RepoKitConfig = RepoKitConfig;

package/dist/TSCompiler.d.ts

@@ -0,0 +1,2 @@
+export declare class TSCompiler {
+}

package/dist/TSCompiler.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TSCompiler = void 0;
+const ts_node_1 = require("ts-node");
+class TSCompiler {
+    static {
+        const service = (0, ts_node_1.register)();
+        service.enabled(true);
+    }
+}
+exports.TSCompiler = TSCompiler;

package/dist/commands/parse_commands.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/parse_commands.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const CommandParser_1 = require("../CommandParser");
+void (async () => {
+    await CommandParser_1.CommandParser.parse();
+})();

package/dist/commands/parse_configuration.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/parse_configuration.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ConfigurationParser_1 = require("../ConfigurationParser");
+ConfigurationParser_1.ConfigurationParser.parse();

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./RepoKitConfig";
+export * from "./RepoKitCommand";
+export * from "./types";

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./RepoKitConfig"), exports);
+__exportStar(require("./RepoKitCommand"), exports);
+__exportStar(require("./types"), exports);

package/dist/types.d.ts

@@ -0,0 +1,21 @@
+import type { RepoKitCommand } from "./RepoKitCommand";
+export interface IRepoKitConfig {
+    project: string;
+    thirdParty?: RepoKitCommand[];
+    commands?: Record<string, ICommand>;
+}
+export interface IRepoKitCommand {
+    name: string;
+    owner?: string;
+    description: string;
+    commands: Record<string, ICommand>;
+}
+export interface ICommand {
+    command: string;
+    description: string;
+    args?: Record<string, string>;
+}
+export interface ILocatedCommand extends IRepoKitCommand {
+    location: string;
+}
+export type AsyncTask<T> = () => Promise<T>;

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/externals/CommandParser.ts

@@ -4,29 +4,24 @@ import { stat } from "node:fs/promises";
 import { existsSync } from "node:fs";
 
 import type { ILocatedCommand } from "./types";
-import { TaskPooler } from "./TaskPooler";
+import { TSCompiler } from "./TSCompiler";
 import { RepoKitCommand } from "./RepoKitCommand";
 /* oxlint-disable typescript-eslint(no-misused-spread) */
 
-export class CommandParser {
+export class CommandParser extends TSCompiler {
   public static async parse() {
     const { paths, root } = this.parsePaths();
     if (!root || !existsSync(root) || !(await stat(root)).isDirectory()) {
       return console.log(JSON.stringify([]));
     }
     const pathList = paths.split(",").filter(Boolean);
-    const pool = new TaskPooler<ILocatedCommand[]>();
-    const results = await Promise.all(
-      pathList.map(path =>
-        pool.enqueue(() => this.parseCommand(join(root, path))),
-      ),
-    );
+    const results = pathList.map(path => this.parseCommand(join(root, path)));
     console.log(JSON.stringify(results.flat()));
   }
 
-  private static async parseCommand(path: string) {
+  private static parseCommand(path: string) {
     const commands: ILocatedCommand[] = [];
-    const declaredExports = await import(path);
+    const declaredExports = require(path);
     for (const key in declaredExports) {
       if (declaredExports[key] instanceof RepoKitCommand) {
         commands.push({ ...declaredExports[key], location: path });

package/externals/ConfigurationParser.ts

@@ -2,16 +2,17 @@ import { parseArgs } from "node:util";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 
+import { TSCompiler } from "./TSCompiler";
 import { RepoKitConfig } from "./RepoKitConfig";
 
-export class ConfigurationParser {
-  public static async parse() {
+export class ConfigurationParser extends TSCompiler {
+  public static parse() {
     const root = this.parseRoot();
     const path = join(root, "repokit.ts");
     if (!existsSync(path)) {
       return;
     }
-    const config = await import(path);
+    const config = require(path);
     for (const key in config) {
       if (config[key] instanceof RepoKitConfig) {
         return console.log(JSON.stringify(config[key].toScoped(path)));

package/externals/TSCompiler.ts

@@ -0,0 +1,8 @@
+import { register } from "ts-node";
+
+export class TSCompiler {
+  static {
+    const service = register();
+    service.enabled(true);
+  }
+}

package/externals/commands/parse_configuration.ts

@@ -1,5 +1,3 @@
 import { ConfigurationParser } from "../ConfigurationParser";
 
-void (async () => {
-  await ConfigurationParser.parse();
-})();
+ConfigurationParser.parse();

package/installation/install.sh

@@ -1,20 +1,16 @@
 
 CWD=$(pwd)
 
-MODULE_DIRECTORY="node_modules"
-
-if [[ "$CWD" != *"$MODULE_DIRECTORY"* ]]; then
-    yarn symlink;
-    exit 0;
-fi
-
 REPLACEMENT="/node_modules"
 FALLBACK_ROOT="${CWD%${REPLACEMENT}*}"
 
-SCRIPT_ORIGIN=$(pwd)
 GIT_ROOT=$(git rev-parse --show-toplevel 2>/dev/null)
 REPO_ROOT=${GIT_ROOT:-$FALLBACK_ROOT}
 
+if [[ "$CWD" != *"$REPLACEMENT"* ]]; then
+    exit 0;
+fi
+
 
 cd $REPO_ROOT
 
@@ -29,28 +25,11 @@ 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 global add tsx
-    elif [ -f "${REPO_ROOT}/pnpm-lock.yaml" ]; then
-        pnpm add -g tsx
-    elif [ -f "${REPO_ROOT}/package-lock.json" ]; then
-        npm i -g 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
+cd $CWD
 
-echo "Compiling from $SCRIPT_ORIGIN"
+echo "Compiling from $CWD"
 
 . "$HOME/.cargo/env"
 RUSTFLAGS="-Awarnings" cargo build --release

package/internals/configuration/configuration.rs

@@ -1,23 +1,24 @@
-use std::{fs::File, io, path::Path, process::exit};
+use std::{path::Path, process::exit};
 
-use crate::{internal_filesystem::internal_filesystem::InternalFileSystem, logger::logger::Logger};
+use crate::{
+    internal_filesystem::{file_builder::FileBuilder, internal_filesystem::InternalFileSystem},
+    logger::logger::Logger,
+};
 
 pub struct Configuration;
 
 impl Configuration {
     pub fn create(root: &str) {
         let file_path = format!("{root}/repokit.ts");
-        let path_buf = Path::new(&file_path);
-        if path_buf.exists() {
+        let path = Path::new(&file_path);
+        if path.exists() {
             return;
         }
         Configuration::welcome();
-        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");
-        target.sync_all().expect("Flushing");
+        let mut source =
+            InternalFileSystem::new(root).resolve_template("configuration_template.txt");
+        let mut target = FileBuilder::create(path, |_| Logger::file_create_error());
+        FileBuilder::copy_to(&mut source, &mut target, |_| Logger::file_write_error());
         Logger::info(
             format!(
                 "Please fill out this file with your desired settings. Then run {}",

package/internals/file_walker/walker.rs

@@ -7,6 +7,8 @@ use std::{
 use ignore::{DirEntry, Error, ParallelVisitor, ParallelVisitorBuilder, WalkState};
 use regex::Regex;
 
+use crate::{internal_filesystem::file_builder::FileBuilder, logger::logger::Logger};
+
 pub struct TSFileVisitor {
     root: String,
     paths: Arc<Mutex<Vec<String>>>,
@@ -17,16 +19,12 @@ impl ParallelVisitor for TSFileVisitor {
         let root_replacer = format!("{}/", self.root);
         let repokit_import_matcher =
             Regex::new(r#"(require\(|from[\s*]?)['"]@repokit/core["'][\)]?[;]?$"#).unwrap();
-        let template_matcher = Regex::new(r"externals\/templates\/[^\s]*?_template\.ts$").unwrap();
         if let Ok(entry) = entry {
             let path = entry.path();
             let path_string = path.to_str().map_or("", |f| f);
-            if entry.file_type().is_some_and(|ft| ft.is_file())
-                && path_string.ends_with(".ts")
-                && !template_matcher.is_match(path_string)
-            {
+            if entry.file_type().is_some_and(|ft| ft.is_file()) && path_string.ends_with(".ts") {
                 let mut open_comment = false;
-                let file: File = File::open(path).expect("file");
+                let file: File = FileBuilder::open(path_string, |_| Logger::open_file_error());
                 let reader: BufReader<File> = BufReader::new(file);
                 for line_result in reader.lines() {
                     let unwrapped = line_result.unwrap();

package/internals/internal_commands/help.rs

@@ -145,7 +145,14 @@ impl Help {
         sort_str_slice(&mut vector);
         vector
             .iter()
-            .map(|&name| RootCommand::from(name, commands.get(name).expect("known keys only")))
+            .map(|&name| {
+                RootCommand::from(
+                    name,
+                    commands
+                        .get(name)
+                        .expect("iteration is over known keys only"),
+                )
+            })
             .collect()
     }
 }

package/internals/internal_commands/register_command.rs

@@ -1,8 +1,6 @@
 use normalize_path::NormalizePath;
 use std::{
     collections::HashMap,
-    fs::{File, create_dir_all},
-    io,
     path::{Path, PathBuf},
     process,
 };
@@ -15,7 +13,7 @@ use crate::{
         },
     },
     internal_commands::help::Help,
-    internal_filesystem::internal_filesystem::InternalFileSystem,
+    internal_filesystem::{file_builder::FileBuilder, internal_filesystem::InternalFileSystem},
     logger::logger::Logger,
 };
 
@@ -56,7 +54,7 @@ impl RegisterCommand {
                 )
                 .as_str(),
             );
-            create_dir_all(&path).expect("");
+            FileBuilder::create_dir_all(&path, |_| Logger::file_directory_error());
         }
         if !path.is_dir() {
             RegisterCommand::exit_on_missing_path();
@@ -90,12 +88,10 @@ 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::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");
-        target.sync_all().expect("Flushing");
+        let mut source =
+            InternalFileSystem::new(&self.scope.root).resolve_template("command_template.txt");
+        let mut target = FileBuilder::create(&command_path, |_| Logger::file_create_error());
+        FileBuilder::copy_to(&mut source, &mut target, |_| Logger::file_write_error());
         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"));

package/internals/internal_commands/typescript_command.rs

@@ -1,4 +1,4 @@
-use std::{path::Path, sync::MutexGuard};
+use std::{path::Path, process::exit, sync::MutexGuard};
 
 use serde_json::from_str;
 
@@ -6,6 +6,7 @@ use crate::{
     configuration::configuration::Configuration,
     executor::executor::Executor,
     internal_filesystem::internal_filesystem::InternalFileSystem,
+    logger::logger::Logger,
     repokit::interfaces::{RepoKitCommand, RepoKitConfig},
 };
 
@@ -22,7 +23,7 @@ impl TypescriptCommand {
 
     pub fn parse_configuration(&self) -> RepoKitConfig {
         let executable =
-            InternalFileSystem::new(&self.root).resolve_command("parse_configuration.ts");
+            InternalFileSystem::new(&self.root).resolve_command("parse_configuration.js");
         let stdout = self.execute(format!("{executable} --root {}", &self.root).as_str());
         if stdout.is_empty() {
             Configuration::create(&self.root);
@@ -33,15 +34,25 @@ impl TypescriptCommand {
 
     pub fn parse_commands(&self, path_list: &MutexGuard<Vec<String>>) -> Vec<RepoKitCommand> {
         let paths = path_list.join(",");
-        let executable = InternalFileSystem::new(&self.root).resolve_command("parse_commands.ts");
+        let executable = InternalFileSystem::new(&self.root).resolve_command("parse_commands.js");
         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
+        let result: Result<Vec<RepoKitCommand>, serde_json::Error> = serde_json::from_str(&stdout);
+        match result {
+            Ok(commands) => commands,
+            Err(_) => {
+                Logger::info("There was an error parsing one of your commands");
+                Logger::info(
+                    "You can validate a command file's syntactical correctness by running",
+                );
+                Logger::log_file_path("tsc --noEmit");
+                exit(0);
+            }
+        }
     }
 
     fn execute(&self, args: &str) -> String {
-        Executor::exec(format!("npx tsx {args}"), |cmd| {
+        Executor::exec(format!("node {args}"), |cmd| {
             cmd.current_dir(Path::new(&self.root))
         })
     }

package/internals/internal_filesystem/file_builder.rs

@@ -0,0 +1,57 @@
+use std::{
+    fs::{File, create_dir_all},
+    io::{Error, copy},
+    path::Path,
+    process::exit,
+};
+
+pub struct FileBuilder;
+
+impl FileBuilder {
+    pub fn open(source: &str, on_error: impl Fn(Error)) -> File {
+        let source = File::open(source);
+        match source {
+            Ok(file) => file,
+            Err(error) => {
+                on_error(error);
+                exit(0);
+            }
+        }
+    }
+
+    pub fn create(destination: &Path, on_error: impl Fn(Error)) -> File {
+        let source = File::create(destination);
+        match source {
+            Ok(file) => file,
+            Err(error) => {
+                on_error(error);
+                exit(0);
+            }
+        }
+    }
+
+    pub fn copy_to(source: &mut File, target: &mut File, on_error: impl Fn(Error)) {
+        let result = copy(source, target);
+        match result {
+            Ok(_) => {
+                let sync = target.sync_all();
+                match sync {
+                    Ok(_) => {}
+                    Err(err) => on_error(err),
+                }
+            }
+            Err(err) => on_error(err),
+        }
+    }
+
+    pub fn create_dir_all(path: &Path, on_error: impl Fn(Error)) {
+        let source = create_dir_all(path);
+        match source {
+            Ok(result) => result,
+            Err(error) => {
+                on_error(error);
+                exit(0);
+            }
+        }
+    }
+}

package/internals/internal_filesystem/internal_filesystem.rs

@@ -1,7 +1,13 @@
 use normalize_path::NormalizePath;
-use std::path::{Path, PathBuf};
+use std::{
+    fs::File,
+    path::{Path, PathBuf},
+};
 
-use crate::{executor::executor::Executor, logger::logger::Logger};
+use crate::{
+    executor::executor::Executor, internal_filesystem::file_builder::FileBuilder,
+    logger::logger::Logger,
+};
 
 pub struct InternalFileSystem {
     root: String,
@@ -23,8 +29,13 @@ impl InternalFileSystem {
         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))
+    pub fn resolve_template(&self, file_name: &str) -> File {
+        let path = self.path_buf_to_str(self.templates_directory().join(file_name));
+        FileBuilder::open(&path, |_| {
+            Logger::error(format!("Unable to locate internal {file_name}").as_str());
+            Logger::error("Please file a bug here");
+            Logger::log_issue_link();
+        })
     }
 
     pub fn find_root() -> String {
@@ -45,15 +56,15 @@ impl InternalFileSystem {
     }
 
     fn commands_directory(&self) -> PathBuf {
-        self.absolute(format!("{}/commands", self.package_directory()).as_str())
+        self.absolute(format!("{}/dist/commands", self.package_directory()).as_str())
     }
 
     fn templates_directory(&self) -> PathBuf {
-        self.absolute(format!("{}/templates", self.package_directory()).as_str())
+        self.absolute(format!("{}/externals/templates", self.package_directory()).as_str())
     }
 
     fn package_directory(&self) -> String {
-        format!("./node_modules/{}/externals", self.package_name())
+        format!("./node_modules/{}", self.package_name())
     }
 
     fn package_name(&self) -> String {

package/internals/internal_filesystem/mod.rs

@@ -1 +1,2 @@
+pub mod file_builder;
 pub mod internal_filesystem;

package/internals/logger/logger.rs

@@ -1,5 +1,6 @@
+use std::process::exit;
+use std::sync::LazyLock;
 use std::sync::Mutex;
-use std::{process, sync::LazyLock};
 
 use colored::{ColoredString, Colorize, CustomColor};
 
@@ -23,12 +24,12 @@ impl Logger {
 
     pub fn exit_with_info(message: &str) {
         Logger::info(message);
-        process::exit(0);
+        exit(0);
     }
 
     pub fn exit_with_error(message: &str) {
         Logger::error(message);
-        process::exit(0);
+        exit(0);
     }
 
     pub fn space_around(message: &str) {
@@ -92,6 +93,33 @@ impl Logger {
         })
     }
 
+    pub fn file_create_error() {
+        Logger::file_error("create a file");
+    }
+
+    pub fn file_directory_error() {
+        Logger::file_error("create a directory");
+    }
+
+    pub fn open_file_error() {
+        Logger::file_error("read a file");
+    }
+
+    pub fn file_write_error() {
+        Logger::file_error("write to a file");
+    }
+
+    pub fn log_issue_link() {
+        Logger::log_file_path("https://github.com/alexfigliolia/repokit/issues");
+    }
+
+    fn file_error(operation: &str) {
+        Logger::info(format!("I was unable to {operation} in your repository").as_str());
+        Logger::error("Please verify the permissions on your working directory or file a bug here");
+        Logger::log_issue_link();
+        exit(0);
+    }
+
     fn info_prefix() -> ColoredString {
         format!("{}: ", *REGISTERED_NAME.lock().unwrap())
             .bright_magenta()

package/internals/repokit/repokit.rs

@@ -36,7 +36,7 @@ impl RepoKit {
         let validator = CommandValidations::from(self);
         let internals = validator.collect_and_validate_internals();
         if internals.contains_key(&command) {
-            let interface = internals.get(&command).expect("exists");
+            let interface = internals.get(&command).expect("Unknown command");
             return interface.run(args, &internals);
         }
         if self.scope.configuration.commands.contains_key(&command) {
@@ -45,7 +45,7 @@ impl RepoKit {
                 .configuration
                 .commands
                 .get(&command)
-                .expect("exists");
+                .expect("Unknown command");
             return Executor::with_stdio(
                 format!("{} {}", root_script.command, &args.join(" ")),
                 |cmd| cmd.current_dir(Path::new(&self.scope.root)),
@@ -56,14 +56,16 @@ impl RepoKit {
             &internals, &externals,
         );
         if externals.contains_key(&command) {
-            let interface = externals.get(&command).expect("exists");
+            let interface = externals.get(&command).expect("Unknown command");
             if args.is_empty() {
                 return self.log_external_command(interface);
             }
             let sub_command = &args[0];
             if interface.commands.contains_key(sub_command) {
-                let script = interface.commands.get(sub_command).expect("exists");
-                let working_dir = Path::new(&interface.location).parent().expect("exists");
+                let script = interface.commands.get(sub_command).expect("Unknown script");
+                let working_dir = Path::new(&interface.location)
+                    .parent()
+                    .expect("Working directory not found");
                 return Executor::with_stdio(
                     format!("{} {}", &script.command, &args[1..].join(" ")),
                     |cmd| cmd.current_dir(working_dir),

package/internals/validations/command_validations.rs

@@ -98,7 +98,7 @@ impl CommandValidations {
         let mut map: HashMap<String, RepoKitCommand> = HashMap::new();
         for command in externals {
             if map.contains_key(&command.name) {
-                let original = map.get(&command.name).expect("existent key");
+                let original = map.get(&command.name).expect("Unknown command");
                 self.on_external_duplicate_collision(command, &original.location);
             }
             map.insert(command.name.clone(), command.clone());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "1.3.6",
+  "version": "1.5.0",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",
@@ -15,31 +15,47 @@
     "type": "git",
     "url": "git+https://github.com/alexfigliolia/repokit.git"
   },
-  "main": "externals/index.ts",
+  "files": [
+    "media",
+    "dist",
+    "externals",
+    "internals",
+    "installation",
+    "Cargo.lock",
+    "Cargo.toml"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
     "build:all": "yarn lint:ts && yarn lint:rust && yarn install:rust",
     "build:rust": "cargo build --release",
+    "build:ts": "tsx devserver/run.ts",
+    "clean:ts": "tsx devserver/run.ts -c",
     "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",
+    "package:ts": "yarn lint:ts && yarn lint:rust && yarn build:ts",
     "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"
+    "run:dev": "yarn build:ts && cargo run --package repokit --bin repokit",
+    "watch:ts": "tsx devserver/run.ts -w"
   },
   "dependencies": {
-    "@figliolia/event-emitter": "^1.1.6",
-    "tsx": "^4.21.0"
+    "@figliolia/event-emitter": "^1.2.0",
+    "ts-node": "^10.9.2"
   },
   "devDependencies": {
-    "@types/node": "^25.2.1",
-    "oxfmt": "^0.33.0",
+    "@figliolia/child-process": "^1.0.4",
+    "@types/node": "^25.3.0",
+    "oxfmt": "^0.34.0",
     "oxlint": "^1.42.0",
-    "oxlint-tsgolint": "^0.13.0",
+    "oxlint-tsgolint": "^0.14.0",
+    "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }
 }

package/externals/TaskPooler.ts

@@ -1,31 +0,0 @@
-import { AutoIncrementingID } from "@figliolia/event-emitter";
-
-import type { AsyncTask } from "./types";
-
-export class TaskPooler<T> {
-  private readonly IDs = new AutoIncrementingID();
-  private readonly runningTasks = new Map<string, Promise<T>>();
-  constructor(public maxSize = 10) {}
-
-  public enqueue(task: AsyncTask<T>) {
-    return new Promise<T>(resolve => {
-      if (this.runningTasks.size < 10) {
-        return resolve(this.indexRunningTask(task));
-      }
-      resolve(this.indexBehindNextOpening(task));
-    });
-  }
-
-  private indexRunningTask(task: AsyncTask<T>) {
-    const ID = this.IDs.get();
-    const promise = task();
-    this.runningTasks.set(ID, promise);
-    void promise.finally(() => this.runningTasks.delete(ID));
-    return promise;
-  }
-
-  private async indexBehindNextOpening(task: AsyncTask<T>) {
-    await Promise.race(this.runningTasks.values());
-    return this.indexRunningTask(task);
-  }
-}