builderman 1.0.0

package/LICENSE

@@ -0,0 +1,7 @@
+ISC License
+
+Copyright (c) 2024-present, LankyMoose
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,5 @@
+# **builderman**
+
+#### _An awesome new package._
+
+<br />

package/dist/index.d.ts

@@ -0,0 +1,31 @@
+export interface TaskConfig {
+    name: string;
+    command: string;
+    cwd: string;
+}
+export interface PipelineTaskConfig {
+    name: string;
+    path?: string;
+    cwd?: string;
+    command: string;
+    requiresEvents?: string[];
+}
+export interface Task extends TaskConfig {
+    requiresEvents: string[];
+}
+export interface Pipeline {
+    run(): Promise<void>;
+}
+/**
+ * Emits an event that can be received by the parent process.
+ * Events are written to stdout in a parseable format.
+ */
+export declare function emit(event: string): void;
+/**
+ * Creates a task configuration.
+ */
+export declare function task(config: TaskConfig): Task;
+/**
+ * Creates a pipeline that manages task execution with event-based dependencies.
+ */
+export declare function pipeline(configs: (Task | PipelineTaskConfig)[]): Pipeline;

package/dist/index.js

@@ -0,0 +1,169 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+const EVENT_PREFIX = "__BUILDERMAN_EVENT__:";
+/**
+ * Emits an event that can be received by the parent process.
+ * Events are written to stdout in a parseable format.
+ */
+export function emit(event) {
+    const eventData = JSON.stringify({ event });
+    console.log(`${EVENT_PREFIX}${eventData}`);
+}
+/**
+ * Creates a task configuration.
+ */
+export function task(config) {
+    return {
+        name: config.name,
+        command: config.command,
+        cwd: config.cwd,
+        requiresEvents: [],
+    };
+}
+/**
+ * Creates a pipeline that manages task execution with event-based dependencies.
+ */
+export function pipeline(configs) {
+    const tasks = configs.map((config) => {
+        if ("requiresEvents" in config || "path" in config) {
+            // It's a PipelineTaskConfig
+            const taskConfig = config;
+            return {
+                name: taskConfig.name,
+                command: taskConfig.command,
+                cwd: taskConfig.path || taskConfig.cwd || process.cwd(),
+                requiresEvents: taskConfig.requiresEvents || [],
+            };
+        }
+        else {
+            // It's already a Task
+            return config;
+        }
+    });
+    return {
+        async run() {
+            const eventEmitter = new EventEmitter();
+            const emittedEvents = new Set();
+            const runningTasks = new Map();
+            const completedTasks = new Set();
+            const taskConfigs = new Map();
+            // Index tasks by name
+            for (const task of tasks) {
+                taskConfigs.set(task.name, task);
+            }
+            // Function to check if a task can start
+            const canStart = (task) => {
+                if (runningTasks.has(task.name) || completedTasks.has(task.name)) {
+                    return false;
+                }
+                return task.requiresEvents.every((event) => emittedEvents.has(event));
+            };
+            // Function to start a task
+            const startTask = (task) => {
+                if (runningTasks.has(task.name)) {
+                    return;
+                }
+                const [command, ...args] = task.command.split(/\s+/);
+                const child = spawn(command, args, {
+                    cwd: task.cwd,
+                    stdio: ["inherit", "pipe", "pipe"],
+                    shell: process.platform === "win32",
+                });
+                runningTasks.set(task.name, child);
+                // Parse events from stdout
+                let stdoutBuffer = "";
+                child.stdout?.on("data", (data) => {
+                    stdoutBuffer += data.toString();
+                    const lines = stdoutBuffer.split("\n");
+                    stdoutBuffer = lines.pop() || "";
+                    for (const line of lines) {
+                        if (line.startsWith(EVENT_PREFIX)) {
+                            try {
+                                const eventData = JSON.parse(line.slice(EVENT_PREFIX.length));
+                                const eventName = eventData.event;
+                                if (eventName && !emittedEvents.has(eventName)) {
+                                    emittedEvents.add(eventName);
+                                    eventEmitter.emit("event", eventName);
+                                }
+                            }
+                            catch (e) {
+                                // Ignore parse errors
+                            }
+                            // Don't forward event lines to stdout
+                        }
+                        else {
+                            // Forward stdout to parent
+                            process.stdout.write(line + "\n");
+                        }
+                    }
+                });
+                // Forward any remaining buffer on end
+                child.stdout?.on("end", () => {
+                    if (stdoutBuffer) {
+                        process.stdout.write(stdoutBuffer);
+                    }
+                });
+                // Forward stderr
+                child.stderr?.on("data", (data) => {
+                    process.stderr.write(data);
+                });
+                // Handle task completion
+                child.on("exit", (code) => {
+                    runningTasks.delete(task.name);
+                    completedTasks.add(task.name);
+                    if (code !== 0) {
+                        process.exitCode = code || 1;
+                    }
+                    // Check if any waiting tasks can now start
+                    eventEmitter.emit("taskCompleted", task.name);
+                });
+            };
+            // Listen for events and task completions to start new tasks
+            eventEmitter.on("event", () => {
+                for (const task of tasks) {
+                    if (canStart(task)) {
+                        startTask(task);
+                    }
+                }
+            });
+            eventEmitter.on("taskCompleted", () => {
+                for (const task of tasks) {
+                    if (canStart(task)) {
+                        startTask(task);
+                    }
+                }
+            });
+            // Start tasks that don't have dependencies
+            for (const task of tasks) {
+                if (canStart(task)) {
+                    startTask(task);
+                }
+            }
+            // Wait for all tasks to complete
+            return new Promise((resolve, reject) => {
+                const checkCompletion = () => {
+                    if (runningTasks.size === 0) {
+                        resolve();
+                    }
+                };
+                eventEmitter.on("taskCompleted", checkCompletion);
+                checkCompletion(); // Check immediately in case all tasks completed synchronously
+                // Handle process termination
+                process.on("SIGINT", () => {
+                    // Kill all running tasks
+                    for (const child of runningTasks.values()) {
+                        child.kill("SIGINT");
+                    }
+                    reject(new Error("Process interrupted"));
+                });
+                process.on("SIGTERM", () => {
+                    // Kill all running tasks
+                    for (const child of runningTasks.values()) {
+                        child.kill("SIGTERM");
+                    }
+                    reject(new Error("Process terminated"));
+                });
+            });
+        },
+    };
+}

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "builderman",
+  "version": "1.0.0",
+  "description": "An awesome new package",
+  "main": "dist/index.js",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/LankyMoose/builderman"
+  },
+  "keywords": [],
+  "author": "LankyMoose",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^25.0.8"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\"",
+    "build": "rm -rf dist && tsc",
+    "dev": "tsc --watch"
+  }
+}