@repokit/core 1.3.7 → 1.6.0

package/dist/CommandParser.d.mts

@@ -0,0 +1,9 @@
+//#region externals/CommandParser.d.ts
+declare class CommandParser {
+  private static compiler?;
+  static parse(): Promise<void>;
+  private static parseCommand;
+  private static parsePaths;
+}
+//#endregion
+export { CommandParser };

package/dist/CommandParser.mjs

@@ -0,0 +1,55 @@
+import { TSCompiler } from "./TSCompiler.mjs";
+import { RepoKitCommand } from "./RepoKitCommand.mjs";
+import { ConcurrencyPool } from "./ConcurrencyPool.mjs";
+import { parseArgs } from "node:util";
+import { stat } from "node:fs/promises";
+import { existsSync } from "node:fs";
+
+//#region externals/CommandParser.ts
+var CommandParser = class {
+	static compiler;
+	static async parse() {
+		const { paths, root } = this.parsePaths();
+		if (!root || !existsSync(root) || !(await stat(root)).isDirectory()) return console.log(JSON.stringify([]));
+		this.compiler = new TSCompiler(root, "parse_commands");
+		const pool = new ConcurrencyPool();
+		const pathList = paths.split(",").filter(Boolean);
+		const commands = await Promise.all(pathList.map((path) => pool.enqueue(() => this.parseCommand(path))));
+		console.log(JSON.stringify(commands.flat()));
+	}
+	static async parseCommand(path) {
+		const commands = [];
+		const declaredExports = await this.compiler?.compile?.(path);
+		for (const key in declaredExports) if (declaredExports[key] instanceof RepoKitCommand) commands.push({
+			...declaredExports[key],
+			location: path
+		});
+		return commands;
+	}
+	static parsePaths() {
+		try {
+			return parseArgs({ options: {
+				paths: {
+					default: "",
+					multiple: false,
+					short: "p",
+					type: "string"
+				},
+				root: {
+					default: "",
+					multiple: false,
+					short: "r",
+					type: "string"
+				}
+			} }).values;
+		} catch {
+			return {
+				paths: "",
+				root: ""
+			};
+		}
+	}
+};
+
+//#endregion
+export { CommandParser };

package/dist/ConcurrencyPool.d.mts

@@ -0,0 +1,13 @@
+import { AsyncTask } from "./types.mjs";
+
+//#region externals/ConcurrencyPool.d.ts
+declare class ConcurrencyPool<T> {
+  readonly maxConcurrency: number;
+  private readonly IDs;
+  private readonly activeTasks;
+  constructor(maxConcurrency?: number);
+  enqueue(task: AsyncTask<T>): Promise<T>;
+  private executeTask;
+}
+//#endregion
+export { ConcurrencyPool };

package/dist/ConcurrencyPool.mjs

@@ -0,0 +1,24 @@
+import { AutoIncrementingID } from "@figliolia/event-emitter";
+
+//#region externals/ConcurrencyPool.ts
+var ConcurrencyPool = class {
+	IDs = new AutoIncrementingID();
+	activeTasks = /* @__PURE__ */ new Map();
+	constructor(maxConcurrency = 10) {
+		this.maxConcurrency = maxConcurrency;
+	}
+	async enqueue(task) {
+		if (this.activeTasks.size === this.maxConcurrency) await Promise.race(Array.from(this.activeTasks.values()));
+		return this.executeTask(task);
+	}
+	executeTask(task) {
+		const ID = this.IDs.get();
+		const promise = task();
+		this.activeTasks.set(ID, promise);
+		promise.finally(() => this.activeTasks.delete(ID));
+		return promise;
+	}
+};
+
+//#endregion
+export { ConcurrencyPool };

package/dist/ConfigurationParser.d.mts

@@ -0,0 +1,9 @@
+import { TSCompiler } from "./TSCompiler.mjs";
+
+//#region externals/ConfigurationParser.d.ts
+declare class ConfigurationParser extends TSCompiler {
+  static parse(): Promise<void>;
+  private static parseRoot;
+}
+//#endregion
+export { ConfigurationParser };

package/dist/ConfigurationParser.mjs

@@ -0,0 +1,27 @@
+import { TSCompiler } from "./TSCompiler.mjs";
+import { RepoKitConfig } from "./RepoKitConfig.mjs";
+import { parseArgs } from "node:util";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+
+//#region externals/ConfigurationParser.ts
+var ConfigurationParser = class extends TSCompiler {
+	static async parse() {
+		const root = this.parseRoot();
+		const path = join(root, "repokit.ts");
+		if (!existsSync(path)) return;
+		const config = await new TSCompiler(root, "parse_configuration").compile(path);
+		for (const key in config) if (config[key] instanceof RepoKitConfig) return console.log(JSON.stringify(config[key].toScoped(path)));
+	}
+	static parseRoot() {
+		return parseArgs({ options: { root: {
+			default: "",
+			multiple: false,
+			short: "r",
+			type: "string"
+		} } }).values.root;
+	}
+};
+
+//#endregion
+export { ConfigurationParser };

package/dist/RepoKitCommand.d.mts

@@ -0,0 +1,17 @@
+import { ICommand, IRepoKitCommand } from "./types.mjs";
+
+//#region externals/RepoKitCommand.d.ts
+declare class RepoKitCommand {
+  name: string;
+  owner: string;
+  description: string;
+  commands: Record<string, ICommand>;
+  constructor({
+    name,
+    description,
+    owner,
+    commands
+  }: IRepoKitCommand);
+}
+//#endregion
+export { RepoKitCommand };

package/dist/RepoKitCommand.mjs

@@ -0,0 +1,16 @@
+//#region externals/RepoKitCommand.ts
+var RepoKitCommand = class {
+	name;
+	owner;
+	description;
+	commands;
+	constructor({ name, description, owner = "", commands = {} }) {
+		this.name = name;
+		this.owner = owner;
+		this.commands = commands;
+		this.description = description;
+	}
+};
+
+//#endregion
+export { RepoKitCommand };

package/dist/RepoKitConfig.d.mts

@@ -0,0 +1,25 @@
+import { RepoKitCommand } from "./RepoKitCommand.mjs";
+import { ICommand, IRepoKitConfig } from "./types.mjs";
+
+//#region externals/RepoKitConfig.d.ts
+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>;
+    }[];
+  };
+}
+//#endregion
+export { RepoKitConfig };

package/dist/RepoKitConfig.mjs

@@ -0,0 +1,25 @@
+import { RepoKitCommand } from "./RepoKitCommand.mjs";
+
+//#region externals/RepoKitConfig.ts
+var RepoKitConfig = class {
+	project;
+	thirdParty;
+	commands;
+	constructor({ project, commands = {}, thirdParty = [] }) {
+		this.project = project;
+		this.commands = commands;
+		this.thirdParty = thirdParty.map((command) => new RepoKitCommand(command));
+	}
+	toScoped(location) {
+		return {
+			...this,
+			thirdParty: this.thirdParty.map((command) => ({
+				...command,
+				location
+			}))
+		};
+	}
+};
+
+//#endregion
+export { RepoKitConfig };

package/dist/TSCompiler.d.mts

@@ -0,0 +1,9 @@
+//#region externals/TSCompiler.d.ts
+declare class TSCompiler {
+  readonly root: string;
+  readonly command: string;
+  constructor(root: string, command: string);
+  compile(path: string): Promise<any>;
+}
+//#endregion
+export { TSCompiler };

package/dist/TSCompiler.mjs

@@ -0,0 +1,20 @@
+import { readFile } from "node:fs/promises";
+import { transform } from "@swc/core";
+
+//#region externals/TSCompiler.ts
+var TSCompiler = class {
+	constructor(root, command) {
+		this.root = root;
+		this.command = command;
+	}
+	async compile(path) {
+		const source = (await readFile(path)).toString();
+		const result = await transform(source, { module: { type: "es6" } });
+		const config = eval(result.code);
+		console.log(config);
+		return config;
+	}
+};
+
+//#endregion
+export { TSCompiler };

package/dist/commands/parse_commands.d.mts

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

package/dist/commands/parse_commands.mjs

@@ -0,0 +1,9 @@
+import { CommandParser } from "../CommandParser.mjs";
+
+//#region externals/commands/parse_commands.ts
+(async () => {
+	await CommandParser.parse();
+})();
+
+//#endregion
+export {  };

package/dist/commands/parse_configuration.d.mts

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

package/dist/commands/parse_configuration.mjs

@@ -0,0 +1,9 @@
+import { ConfigurationParser } from "../ConfigurationParser.mjs";
+
+//#region externals/commands/parse_configuration.ts
+(async () => {
+	await ConfigurationParser.parse();
+})();
+
+//#endregion
+export {  };

package/dist/index.d.mts

@@ -0,0 +1,4 @@
+import { RepoKitCommand } from "./RepoKitCommand.mjs";
+import { AsyncTask, ICommand, ILocatedCommand, IRepoKitCommand, IRepoKitConfig } from "./types.mjs";
+import { RepoKitConfig } from "./RepoKitConfig.mjs";
+export { AsyncTask, ICommand, ILocatedCommand, IRepoKitCommand, IRepoKitConfig, RepoKitCommand, RepoKitConfig };

package/dist/index.mjs

@@ -0,0 +1,4 @@
+import { RepoKitCommand } from "./RepoKitCommand.mjs";
+import { RepoKitConfig } from "./RepoKitConfig.mjs";
+
+export { RepoKitCommand, RepoKitConfig };

package/dist/templates/command_template.mjs

@@ -0,0 +1,5 @@
+//#region externals/templates/command_template.txt
+var command_template_default = "import { RepoKitCommand } from \"@repokit/core\";\n\n/**\n * Please fill out this command file with your desired settings\n */\nexport const Commands = new RepoKitCommand({\n  name: \"<Your Package Name>\",\n  owner: \"<Optional Team or Individual>\",\n  description: \"<Your Package Description>\",\n  commands: {\n    \"<your-first-command>\": {\n      command: \"<insert shell command here>\",\n      description: \"A description for using your command\",\n    },\n    \"<your-second-command>\": {\n      command: \"<insert shell command here>\",\n      description: \"A description for using your command\",\n    },\n    \"<your-third-command>\": {\n      command: \"<insert shell command here>\",\n      description: \"A description for using your command\",\n    },\n  },\n});\n";
+
+//#endregion
+export { command_template_default as default };

package/dist/templates/configuration_template.mjs

@@ -0,0 +1,5 @@
+//#region externals/templates/configuration_template.txt
+var configuration_template_default = "import { RepoKitConfig } from \"@repokit/core\";\n\n/**\n * Please fill out this config file with your desired\n * repokit settings\n */\nexport const RepoKit = new RepoKitConfig({\n  project: \"Your Project Name\",\n  commands: {\n    \"<your-first-command>\": {\n      command: \"<insert shell command here>\",\n      description: \"A description for using your command\",\n    },\n    \"<your-second-command>\": {\n      command: \"<insert shell command here>\",\n      description: \"A description for using your command\",\n    },\n    \"<your-third-command>\": {\n      command: \"<insert shell command here>\",\n      description: \"A description for using your command\",\n    },\n  },\n});\n";
+
+//#endregion
+export { configuration_template_default as default };

package/dist/types.d.mts

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

package/dist/types.mjs

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

package/externals/CommandParser.ts

@@ -1,32 +1,33 @@
 import { parseArgs } from "node:util";
-import { join } from "node:path";
 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";
+import { ConcurrencyPool } from "./ConcurrencyPool";
 /* oxlint-disable typescript-eslint(no-misused-spread) */
 
 export class CommandParser {
+  private static compiler?: TSCompiler;
+
   public static async parse() {
     const { paths, root } = this.parsePaths();
     if (!root || !existsSync(root) || !(await stat(root)).isDirectory()) {
       return console.log(JSON.stringify([]));
     }
+    this.compiler = new TSCompiler(root, "parse_commands");
+    const pool = new ConcurrencyPool<ILocatedCommand[]>();
     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 commands = await Promise.all(
+      pathList.map(path => pool.enqueue(() => this.parseCommand(path))),
     );
-    console.log(JSON.stringify(results.flat()));
+    console.log(JSON.stringify(commands.flat()));
   }
 
   private static async parseCommand(path: string) {
     const commands: ILocatedCommand[] = [];
-    const declaredExports = await import(path);
+    const declaredExports = await this.compiler?.compile?.(path);
     for (const key in declaredExports) {
       if (declaredExports[key] instanceof RepoKitCommand) {
         commands.push({ ...declaredExports[key], location: path });

package/externals/ConcurrencyPool.ts

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

package/externals/ConfigurationParser.ts

@@ -2,16 +2,18 @@ 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 {
+export class ConfigurationParser extends TSCompiler {
   public static async parse() {
     const root = this.parseRoot();
     const path = join(root, "repokit.ts");
     if (!existsSync(path)) {
       return;
     }
-    const config = await import(path);
+    const compiler = new TSCompiler(root, "parse_configuration");
+    const config = await compiler.compile(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,26 @@
+import { basename, resolve } from "node:path";
+import { readFile, rm, writeFile } from "node:fs/promises";
+
+import { transform } from "@swc/core";
+
+export class TSCompiler {
+  private static readonly TMP_FILE_NAME = ".repokit_tmp.js";
+  constructor(
+    public readonly root: string,
+    public readonly command: string,
+  ) {}
+
+  public async compile(path: string) {
+    const source = (await readFile(path)).toString();
+    const result = await transform(source, {
+      module: {
+        type: "es6",
+      },
+    });
+    const target = `${resolve(path, "../")}/${basename(path)}${TSCompiler.TMP_FILE_NAME}`;
+    await writeFile(target, result.code);
+    const config = await import(target);
+    await rm(target, { force: true });
+    return config;
+  }
+}

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

@@ -12,11 +12,18 @@ impl Configuration {
         let file_path = format!("{root}/repokit.ts");
         let path = Path::new(&file_path);
         if path.exists() {
-            return;
+            Logger::info(
+                format!(
+                    "I found a Repokit configuration without an exported {} instance",
+                    Logger::blue("RepokitConfig")
+                )
+                .as_str(),
+            );
+            return Logger::exit_with_info("Please create an instance and export it");
         }
         Configuration::welcome();
         let mut source =
-            InternalFileSystem::new(root).resolve_template("configuration_template.ts");
+            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(

package/internals/file_walker/walker.rs

@@ -19,14 +19,10 @@ 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 = FileBuilder::open(path_string, |_| Logger::open_file_error());
                 let reader: BufReader<File> = BufReader::new(file);

package/internals/internal_commands/register_command.rs

@@ -89,7 +89,7 @@ impl InternalExecutable for RegisterCommand {
         Logger::info("Registering a new command");
         let command_path = self.validate_path(args);
         let mut source =
-            InternalFileSystem::new(&self.scope.root).resolve_template("command_template.ts");
+            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");

package/internals/internal_commands/typescript_command.rs

@@ -22,8 +22,7 @@ impl TypescriptCommand {
     }
 
     pub fn parse_configuration(&self) -> RepoKitConfig {
-        let executable =
-            InternalFileSystem::new(&self.root).resolve_command("parse_configuration.ts");
+        let executable = InternalFileSystem::new(&self.root).resolve_command("parse_configuration");
         let stdout = self.execute(format!("{executable} --root {}", &self.root).as_str());
         if stdout.is_empty() {
             Configuration::create(&self.root);
@@ -34,7 +33,7 @@ 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");
         let stdout =
             self.execute(format!("{executable} --paths {paths} --root {}", self.root).as_str());
         let result: Result<Vec<RepoKitCommand>, serde_json::Error> = serde_json::from_str(&stdout);
@@ -52,7 +51,7 @@ impl TypescriptCommand {
     }
 
     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/internal_filesystem.rs

@@ -25,8 +25,11 @@ impl InternalFileSystem {
         path.join(segment).normalize()
     }
 
-    pub fn resolve_command(&self, file_name: &str) -> String {
-        self.path_buf_to_str(self.commands_directory().join(file_name))
+    pub fn resolve_command(&self, command_name: &str) -> String {
+        self.path_buf_to_str(
+            self.commands_directory()
+                .join(format!("{command_name}.mjs")),
+        )
     }
 
     pub fn resolve_template(&self, file_name: &str) -> File {
@@ -56,15 +59,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "1.3.7",
+  "version": "1.6.0",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",
@@ -15,31 +15,48 @@
     "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.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mjs",
   "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",
+    "@swc/core": "^1.15.18"
   },
   "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.14.0",
+    "tsdown": "^0.20.3",
+    "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);
-  }
-}