builderman 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -1,25 +1,26 @@
+export interface Commands {
+    dev: string;
+    build: string;
+}
 export interface TaskConfig {
     name: string;
-    command: string;
+    commands: Commands;
     cwd: string;
-    requiresEvents?: string[];
+    readyOn?: (output: string) => boolean;
+    dependsOn?: Dependency[];
 }
+export type Dependency = Promise<void> | (() => Promise<void>);
 export interface Task extends TaskConfig {
-    requiresEvents: string[];
+    readyOrComplete(): Promise<void>;
 }
 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.
+ * Creates a pipeline that manages task execution with dependency-based coordination.
  */
 export declare function pipeline(tasks: Task[]): Pipeline;

package/dist/index.js

@@ -1,70 +1,95 @@
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
 import * as path from "node:path";
-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: config.requiresEvents || [],
+    let resolveReady = null;
+    const readyPromise = new Promise((resolve) => {
+        resolveReady = resolve;
+    });
+    let isReady = false;
+    let isComplete = false;
+    const task = {
+        ...config,
+        dependsOn: config.dependsOn || [],
+        readyOrComplete() {
+            return readyPromise;
+        },
+    };
+    task._markReady = () => {
+        if (!isReady && resolveReady) {
+            isReady = true;
+            resolveReady();
+        }
+    };
+    task._markComplete = () => {
+        if (!isComplete) {
+            isComplete = true;
+            if (!isReady && resolveReady) {
+                isReady = true;
+                resolveReady();
+            }
+        }
     };
+    task._isReady = () => isReady;
+    task._isComplete = () => isComplete;
+    return task;
 }
 /**
- * Creates a pipeline that manages task execution with event-based dependencies.
+ * Creates a pipeline that manages task execution with dependency-based coordination.
  */
 export function pipeline(tasks) {
     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) => {
+            const readyTasks = new Set();
+            // Determine which command to use based on NODE_ENV
+            const isProduction = process.env.NODE_ENV === "production";
+            const getCommand = (task) => {
+                return isProduction ? task.commands.build : task.commands.dev;
+            };
+            // Function to check if a task's dependencies are satisfied
+            const canStart = async (task) => {
                 if (runningTasks.has(task.name) || completedTasks.has(task.name)) {
                     return false;
                 }
-                return task.requiresEvents.every((event) => emittedEvents.has(event));
+                if (!task.dependsOn || task.dependsOn.length === 0) {
+                    return true;
+                }
+                // Wait for all dependencies
+                for (const dep of task.dependsOn) {
+                    if (typeof dep === "function") {
+                        await dep();
+                    }
+                    else {
+                        await dep;
+                    }
+                }
+                return true;
             };
             // Function to start a task
-            const startTask = (task) => {
+            const startTask = async (task) => {
                 if (runningTasks.has(task.name)) {
                     return;
                 }
+                const command = getCommand(task);
                 // Ensure node_modules/.bin is in PATH for local dependencies
-                // Resolve cwd relative to current working directory
                 const taskCwd = path.isAbsolute(task.cwd)
                     ? task.cwd
                     : path.resolve(process.cwd(), task.cwd);
                 const localBinPath = path.join(taskCwd, "node_modules", ".bin");
-                // Build PATH with local node_modules/.bin first (as absolute path), then existing PATH
+                // Build PATH with local node_modules/.bin first
                 const existingPath = process.env.PATH || process.env.Path || "";
                 const pathSeparator = process.platform === "win32" ? ";" : ":";
-                // Collect all potential bin paths (local first, then root, then existing)
                 const binPaths = [localBinPath];
-                // Also add root node_modules/.bin if different from local
                 const rootBinPath = path.join(process.cwd(), "node_modules", ".bin");
                 if (rootBinPath !== localBinPath) {
                     binPaths.push(rootBinPath);
                 }
-                // Add existing PATH
                 if (existingPath) {
                     binPaths.push(existingPath);
                 }
@@ -72,41 +97,50 @@ export function pipeline(tasks) {
                 const env = {
                     ...process.env,
                     PATH: newPath,
-                    Path: newPath, // Windows uses both PATH and Path
+                    Path: newPath,
                 };
-                // Use shell mode to allow commands like "vite dev" to work properly
-                const child = spawn(task.command, {
+                const child = spawn(command, {
                     cwd: task.cwd,
                     stdio: ["inherit", "pipe", "pipe"],
                     shell: true,
                     env,
                 });
+                // Handle spawn errors
+                child.on("error", (error) => {
+                    console.error(`[${task.name}] Failed to start:`, error.message);
+                    runningTasks.delete(task.name);
+                    completedTasks.add(task.name);
+                    task._markComplete();
+                    process.exitCode = 1;
+                    eventEmitter.emit("taskCompleted", task.name);
+                });
                 runningTasks.set(task.name, child);
-                // Parse events from stdout
+                // If task doesn't have readyOn, mark as ready immediately
+                if (!task.readyOn) {
+                    readyTasks.add(task.name);
+                    task._markReady();
+                    eventEmitter.emit("taskReady", task.name);
+                }
+                // Monitor stdout for readiness
                 let stdoutBuffer = "";
+                let allOutput = "";
                 child.stdout?.on("data", (data) => {
-                    stdoutBuffer += data.toString();
+                    const chunk = data.toString();
+                    allOutput += chunk;
+                    stdoutBuffer += chunk;
                     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);
-                                }
+                        // Check if task is ready based on readyOn callback
+                        if (task.readyOn && !readyTasks.has(task.name)) {
+                            if (task.readyOn(allOutput)) {
+                                readyTasks.add(task.name);
+                                task._markReady();
+                                eventEmitter.emit("taskReady", task.name);
                             }
-                            catch (e) {
-                                // Ignore parse errors
-                            }
-                            // Don't forward event lines to stdout
-                        }
-                        else {
-                            // Forward stdout to parent
-                            process.stdout.write(line + "\n");
                         }
+                        // Forward stdout to parent
+                        process.stdout.write(line + "\n");
                     }
                 });
                 // Forward any remaining buffer on end
@@ -123,34 +157,26 @@ export function pipeline(tasks) {
                 child.on("exit", (code) => {
                     runningTasks.delete(task.name);
                     completedTasks.add(task.name);
+                    task._markComplete();
                     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", () => {
+            // Function to try starting tasks when dependencies are ready
+            const tryStartTasks = async () => {
                 for (const task of tasks) {
-                    if (canStart(task)) {
-                        startTask(task);
+                    if (await canStart(task)) {
+                        await startTask(task);
                     }
                 }
-            });
+            };
+            // Listen for task readiness and completion to start dependent tasks
+            eventEmitter.on("taskReady", tryStartTasks);
+            eventEmitter.on("taskCompleted", tryStartTasks);
             // Start tasks that don't have dependencies
-            for (const task of tasks) {
-                if (canStart(task)) {
-                    startTask(task);
-                }
-            }
+            await tryStartTasks();
             // Wait for all tasks to complete
             return new Promise((resolve, reject) => {
                 const checkCompletion = () => {
@@ -159,17 +185,15 @@ export function pipeline(tasks) {
                     }
                 };
                 eventEmitter.on("taskCompleted", checkCompletion);
-                checkCompletion(); // Check immediately in case all tasks completed synchronously
+                checkCompletion();
                 // 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");
                     }

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "builderman",
-  "version": "1.0.1",
-  "description": "An awesome new package",
+  "version": "1.0.3",
+  "description": "Simple task runner for building and developing projects.",
   "main": "dist/index.js",
   "type": "module",
   "repository": {
     "type": "git",
     "url": "https://github.com/LankyMoose/builderman"
   },
-  "keywords": [],
+  "keywords": [
+    "task",
+    "runner",
+    "build",
+    "development",
+    "pipeline"
+  ],
   "author": "LankyMoose",
   "license": "ISC",
   "devDependencies": {