@repokit/core 1.3.7 → 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

@@ -16,7 +16,7 @@ impl Configuration {
         }
         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

@@ -23,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);
@@ -34,7 +34,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.js");
         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 +52,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

@@ -56,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@repokit/core",
-  "version": "1.3.7",
+  "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.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);
-  }
-}