@repokit/core 0.0.1

package/dist/types/commands/parse_configuration.d.ts

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

package/dist/types/index.d.ts

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

package/dist/types/types.d.ts

@@ -0,0 +1,18 @@
+export interface IRepoKitConfig {
+    project: string;
+    commands?: Record<string, ICommand>;
+}
+export interface IRepoKitCommand {
+    name: string;
+    owner?: string;
+    description: string;
+    commands: Record<string, ICommand>;
+}
+export interface ICommand {
+    command: string;
+    description: string;
+}
+export interface ILocatedCommand extends IRepoKitCommand {
+    location: string;
+}
+export type AsyncTask<T> = () => Promise<T>;

package/install.sh

@@ -0,0 +1,43 @@
+set -e 
+
+REPO_ROOT=$(git rev-parse --show-toplevel)
+
+cd $REPO_ROOT
+
+command_exists() {
+    command -v "$1" >/dev/null 2>&1
+}
+
+if command_exists rustc && command_exists cargo; then
+    echo "Rust is installed."
+else
+    echo "Installing rust"
+    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y
+fi
+
+if npm list --depth=0 tsx >/dev/null 2>&1; then
+    echo "Found tsx installation"
+else
+    # Node Dependencies installation
+    if [ -f "${REPO_ROOT}/yarn.lock" ]; then
+        yarn add -D tsx
+    elif [ -f "${REPO_ROOT}/pnpm-lock.yaml" ]; then
+        pnpm add -D tsx
+    elif [ -f "${REPO_ROOT}/package-lock.json" ]; then
+        npm i -D tsx
+    else
+        echo "No node.js package manager detected"
+        echo "Run npm init to create your node.js project"
+    fi
+fi
+
+
+echo "Installing Repokit CLI"
+
+SCRIPT_DIR=$(dirname "$(readlink -f "$0")")
+cd "$SCRIPT_DIR"
+
+. "$HOME/.cargo/env"
+RUSTFLAGS="-Awarnings" cargo build --release > /dev/null
+cargo install --path . > /dev/null
+repokit

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@repokit/core",
+  "version": "0.0.1",
+  "description": "A knowledgebase for your repository - wrapped in a CLI",
+  "license": "MIT",
+  "author": "Alex Figliolia",
+  "main": "dist/cjs/index.js",
+  "module": "dist/mjs/index.js",
+  "types": "dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/mjs/index.js",
+      "require": "./dist/cjs/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build:all": "yarn build:ts && yarn lint:all && yarn install:repokit",
+    "build:rust": "cargo build --release",
+    "build:ts": "yarn ts-packager -e src",
+    "install:repokit": "yarn build:rust && cargo install --path .",
+    "lint:all": "repokit format:rust && repokit lint:ts",
+    "postinstall": "chmod +x ./install.sh && ./install.sh",
+    "repokit": "yarn build:ts && yarn install:repokit && repokit",
+    "run:dev": "cargo run --package repokit --bin repokit"
+  },
+  "devDependencies": {
+    "@figliolia/event-emitter": "^1.1.6",
+    "@figliolia/ts-packager": "^1.2.1",
+    "@types/node": "^25.0.10",
+    "oxfmt": "^0.27.0",
+    "oxlint": "^1.42.0",
+    "oxlint-tsgolint": "^0.11.3",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3"
+  }
+}

package/repokit.ts

@@ -0,0 +1,36 @@
+import { RepoKitConfig } from "@repokit/core";
+
+export const RepoKit = new RepoKitConfig({
+  project: "Repokit",
+  commands: {
+    "lint:rust": {
+      command: "cargo clippy",
+      description: "Lints rust files",
+    },
+    "format:rust": {
+      command: "cargo clippy --fix --allow-dirty",
+      description: "Formats rust files",
+    },
+    "build:rust": {
+      command: "cargo build --release",
+      description: "Build CLI in production mode",
+    },
+    "run:rust": {
+      command: "cargo run --package repokit --bin repokit",
+      description: "Run CLI in development mode",
+    },
+    "install:rust": {
+      command: "repokit build:rust && cargo install --path .",
+      description: "Installs the production CLI and adds it to your path",
+    },
+    "lint:ts": {
+      command:
+        "yarn oxlint --type-aware --type-check --report-unused-disable-directives --fix && yarn oxfmt",
+      description: "Lints typescript files",
+    },
+    "build:ts": {
+      command: "yarn ts-packager -e src",
+      description: "Builds the typescript package",
+    },
+  },
+});

package/src/CommandParser.ts

@@ -0,0 +1,59 @@
+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 { RepoKitCommand } from "./RepoKitCommand";
+
+export class CommandParser {
+  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))),
+      ),
+    );
+    console.log(JSON.stringify(results.flat()));
+  }
+
+  private static async parseCommand(path: string) {
+    const commands: ILocatedCommand[] = [];
+    const declaredExports = await import(path);
+    for (const key in declaredExports) {
+      if (declaredExports[key] instanceof RepoKitCommand) {
+        commands.push({ ...declaredExports[key].toJSON(), location: path });
+      }
+    }
+    return commands;
+  }
+
+  private 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: "" };
+    }
+  }
+}

package/src/ConfigurationParser.ts

@@ -0,0 +1,34 @@
+import { parseArgs } from "node:util";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+
+import { RepoKitConfig } from "./RepoKitConfig";
+
+export class ConfigurationParser {
+  public static async parse() {
+    const root = this.parseRoot();
+    const path = join(root, "repokit.ts");
+    if (!existsSync(path)) {
+      return;
+    }
+    const config = await import(path);
+    for (const key in config) {
+      if (config[key] instanceof RepoKitConfig) {
+        return console.log(JSON.stringify(config[key]));
+      }
+    }
+  }
+
+  private static parseRoot() {
+    return parseArgs({
+      options: {
+        root: {
+          default: "",
+          multiple: false,
+          short: "r",
+          type: "string",
+        },
+      },
+    }).values.root;
+  }
+}

package/src/RepoKitCommand.ts

@@ -0,0 +1,24 @@
+import type { ICommand, IRepoKitCommand } from "./types";
+
+export class RepoKitCommand {
+  name: string;
+  owner: string;
+  description: string;
+  commands: Record<string, ICommand>;
+  constructor({
+    name,
+    description,
+    owner = "",
+    commands = {},
+  }: IRepoKitCommand) {
+    this.name = name;
+    this.owner = owner;
+    this.commands = commands;
+    this.description = description;
+  }
+
+  public toJSON() {
+    const { name, owner, commands, description } = this;
+    return { name, owner, commands, description };
+  }
+}

package/src/RepoKitConfig.ts

@@ -0,0 +1,10 @@
+import type { ICommand, IRepoKitConfig } from "./types";
+
+export class RepoKitConfig implements Required<IRepoKitConfig> {
+  project: string;
+  commands: Record<string, ICommand>;
+  constructor({ project, commands = {} }: IRepoKitConfig) {
+    this.project = project;
+    this.commands = commands;
+  }
+}

package/src/TaskPooler.ts

@@ -0,0 +1,31 @@
+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);
+  }
+}

package/src/commands/parse_commands.ts

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

package/src/commands/parse_configuration.ts

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

package/src/index.ts

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

package/src/types.ts

@@ -0,0 +1,22 @@
+export interface IRepoKitConfig {
+  project: string;
+  commands?: Record<string, ICommand>;
+}
+
+export interface IRepoKitCommand {
+  name: string;
+  owner?: string;
+  description: string;
+  commands: Record<string, ICommand>;
+}
+
+export interface ICommand {
+  command: string;
+  description: string;
+}
+
+export interface ILocatedCommand extends IRepoKitCommand {
+  location: string;
+}
+
+export type AsyncTask<T> = () => Promise<T>;

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "module": "nodenext",
+    "target": "esnext",
+    "lib": ["ESNext"],
+    "moduleResolution": "nodenext",
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitReturns": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "strict": true,
+    "isolatedModules": true,
+    "noUncheckedSideEffectImports": true,
+    "moduleDetection": "force",
+    "skipLibCheck": true,
+    "paths": {
+      "@repokit/core": ["./src/index.ts"]
+    }
+  }
+}

package/workspaces/concurrency/mod.rs

@@ -0,0 +1 @@
+pub mod thread_pool;

package/workspaces/concurrency/thread_pool.rs

@@ -0,0 +1,32 @@
+use tokio::{
+    runtime::{self, Runtime},
+    task::JoinHandle,
+};
+
+pub struct ThreadPool {
+    pub pool: Runtime,
+}
+
+impl ThreadPool {
+    pub fn new(threads_override: Option<usize>, pool_override: Option<Runtime>) -> ThreadPool {
+        let pool = pool_override.unwrap_or(ThreadPool::create_pool(threads_override));
+        ThreadPool { pool }
+    }
+
+    pub fn spawn<T: Send + 'static, F: (Fn() -> T) + 'static + Send>(
+        &mut self,
+        task: F,
+    ) -> JoinHandle<T> {
+        self.pool.spawn(async move { task() })
+    }
+
+    fn create_pool(threads: Option<usize>) -> Runtime {
+        let mut pool = runtime::Builder::new_multi_thread();
+        pool.enable_all();
+        match threads {
+            Some(size) => pool.worker_threads(size),
+            None => &pool,
+        };
+        pool.build().unwrap()
+    }
+}

package/workspaces/configuration/configuration.rs

@@ -0,0 +1,47 @@
+use std::{
+    fs::File,
+    io,
+    path::{Path, PathBuf},
+    process::exit,
+};
+
+use crate::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() {
+            return;
+        }
+        Configuration::welcome();
+        let mut source = File::open(Configuration::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");
+        Logger::info(
+            format!(
+                "Please fill out this file with your desired settings. Then run {}",
+                Logger::blue_bright("repokit onboard")
+            )
+            .as_str(),
+        );
+        Logger::log_file_path(file_path.as_str());
+        exit(0);
+    }
+
+    fn welcome() {
+        Logger::info("Welcome to Repokit! Let's get you setup");
+        Logger::info("Creating your configuration file:");
+    }
+
+    fn template_path() -> PathBuf {
+        let file_path = file!();
+        let dir = Path::new(file_path)
+            .parent()
+            .expect("Failed to get parent directory");
+        dir.join("configuration_template.ts")
+    }
+}

package/workspaces/configuration/configuration_template.ts

@@ -0,0 +1,23 @@
+import { RepoKitConfig } from "@repokit/core";
+
+/**
+ * Please fill out this config file with your desired
+ * repokit settings
+ */
+export const RepoKit = new RepoKitConfig({
+  project: "Your Project Name",
+  commands: {
+    "<your-first-command>": {
+      command: "<insert shell command here>",
+      description: "A description for using your command",
+    },
+    "<your-second-command>": {
+      command: "<insert shell command here>",
+      description: "A description for using your command",
+    },
+    "<your-third-command>": {
+      command: "<insert shell command here>",
+      description: "A description for using your command",
+    },
+  },
+});

package/workspaces/configuration/mod.rs

@@ -0,0 +1 @@
+pub mod configuration;

package/workspaces/executables/external_executable.rs

@@ -0,0 +1,4 @@
+trait ExternalExecutable {
+    fn run(command: String, args: Vec<String>);
+    fn help(&self);
+}

package/workspaces/executables/intenal_executable.rs

@@ -0,0 +1,9 @@
+use std::collections::HashMap;
+
+use crate::executables::internal_executable_definition::InternalExecutableDefinition;
+
+pub trait InternalExecutable {
+    fn run(&self, args: Vec<String>, internals: &HashMap<String, Box<dyn InternalExecutable>>);
+    fn help(&self);
+    fn get_definition(&self) -> &InternalExecutableDefinition;
+}

package/workspaces/executables/internal_executable_definition.rs

@@ -0,0 +1,8 @@
+use std::collections::HashMap;
+
+#[derive(Clone)]
+pub struct InternalExecutableDefinition {
+    pub name: &'static str,
+    pub description: &'static str,
+    pub args: HashMap<&'static str, &'static str>,
+}

package/workspaces/executables/mod.rs

@@ -0,0 +1,3 @@
+pub mod external_executable;
+pub mod intenal_executable;
+pub mod internal_executable_definition;

package/workspaces/executor/executor.rs

@@ -0,0 +1,62 @@
+use std::ffi::OsStr;
+use std::process::Command;
+use std::str;
+
+pub struct Executor {}
+
+impl Executor {
+    pub fn exec<T: AsRef<OsStr>>(
+        command: T,
+        composer: impl Fn(&mut Command) -> &mut Command,
+    ) -> String {
+        let output = composer(&mut Executor::spawn(command))
+            .output()
+            .expect("command failed to execute");
+        if output.status.success() {
+            return Executor::unwrap(&output.stdout);
+        }
+        Executor::unwrap(&output.stderr)
+    }
+
+    pub fn with_stdio<T: AsRef<OsStr>>(
+        command: T,
+        composer: impl Fn(&mut Command) -> &mut Command,
+    ) {
+        let mut child = composer(&mut Executor::spawn(command))
+            .spawn()
+            .expect("Failed to execute");
+        child.wait().expect("failed to wait on child process");
+    }
+
+    pub fn spawn<T: AsRef<OsStr>>(program: T) -> Command {
+        let mut command = Executor::platform_command();
+        command.arg(program);
+        command
+    }
+
+    fn platform_command() -> Command {
+        if cfg!(target_os = "windows") {
+            return Executor::windows_command();
+        }
+        Executor::unix_command()
+    }
+
+    fn windows_command() -> Command {
+        let mut child_process = Command::new("cmd");
+        child_process.arg("/C");
+        child_process
+    }
+
+    fn unix_command() -> Command {
+        let mut child_process = Command::new("sh");
+        child_process.arg("-c");
+        child_process
+    }
+
+    fn unwrap(io: &[u8]) -> String {
+        str::from_utf8(io)
+            .expect("Invalid output")
+            .trim()
+            .to_string()
+    }
+}

package/workspaces/executor/mod.rs

@@ -0,0 +1 @@
+pub mod executor;