@repokit/core 1.5.0 → 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,27 +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 { TSCompiler } from "./TSCompiler";
 import { RepoKitCommand } from "./RepoKitCommand";
+import { ConcurrencyPool } from "./ConcurrencyPool";
 /* oxlint-disable typescript-eslint(no-misused-spread) */
 
-export class CommandParser extends TSCompiler {
+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 results = pathList.map(path => this.parseCommand(join(root, path)));
-    console.log(JSON.stringify(results.flat()));
+    const commands = await Promise.all(
+      pathList.map(path => pool.enqueue(() => this.parseCommand(path))),
+    );
+    console.log(JSON.stringify(commands.flat()));
   }
 
-  private static parseCommand(path: string) {
+  private static async parseCommand(path: string) {
     const commands: ILocatedCommand[] = [];
-    const declaredExports = require(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

@@ -6,13 +6,14 @@ import { TSCompiler } from "./TSCompiler";
 import { RepoKitConfig } from "./RepoKitConfig";
 
 export class ConfigurationParser extends TSCompiler {
-  public static parse() {
+  public static async parse() {
     const root = this.parseRoot();
     const path = join(root, "repokit.ts");
     if (!existsSync(path)) {
       return;
     }
-    const config = require(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

@@ -1,8 +1,26 @@
-import { register } from "ts-node";
+import { basename, resolve } from "node:path";
+import { readFile, rm, writeFile } from "node:fs/promises";
+
+import { transform } from "@swc/core";
 
 export class TSCompiler {
-  static {
-    const service = register();
-    service.enabled(true);
+  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/externals/commands/parse_configuration.ts

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

package/internals/configuration/configuration.rs

@@ -12,7 +12,14 @@ 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 =

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.js");
+        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.js");
+        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);

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 {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "A knowledgebase for your repository - wrapped in a CLI",
   "keywords": [
     "cli",
@@ -24,9 +24,9 @@
     "Cargo.lock",
     "Cargo.toml"
   ],
-  "main": "./dist/index.js",
-  "module": "./dist/index.js",
-  "types": "./dist/index.d.ts",
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mjs",
   "publishConfig": {
     "access": "public"
   },
@@ -47,7 +47,7 @@
   },
   "dependencies": {
     "@figliolia/event-emitter": "^1.2.0",
-    "ts-node": "^10.9.2"
+    "@swc/core": "^1.15.18"
   },
   "devDependencies": {
     "@figliolia/child-process": "^1.0.4",
@@ -55,6 +55,7 @@
     "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/dist/CommandParser.d.ts

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

package/dist/CommandParser.js

@@ -1,55 +0,0 @@
-"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

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

package/dist/ConfigurationParser.js

@@ -1,36 +0,0 @@
-"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

@@ -1,8 +0,0 @@
-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

@@ -1,16 +0,0 @@
-"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

@@ -1,17 +0,0 @@
-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

@@ -1,22 +0,0 @@
-"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

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

package/dist/TSCompiler.js

@@ -1,11 +0,0 @@
-"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

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

package/dist/commands/parse_commands.js

@@ -1,6 +0,0 @@
-"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

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

package/dist/commands/parse_configuration.js

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

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,19 +0,0 @@
-"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

@@ -1,21 +0,0 @@
-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

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