builderman 1.0.2 → 1.0.4

package/dist/constants.d.ts

@@ -0,0 +1 @@
+export declare const $TASK_INTERNAL: unique symbol;

package/dist/constants.js

@@ -0,0 +1 @@
+export const $TASK_INTERNAL = Symbol("task-internal");

package/dist/index.d.ts

@@ -1,25 +1,3 @@
-export interface TaskConfig {
-    name: string;
-    command: string;
-    cwd: 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(tasks: Task[]): Pipeline;
+export * from "./task.js";
+export * from "./pipeline.js";
+export type { Task, Pipeline, TaskConfig } from "./types.js";

package/dist/index.js

@@ -1,190 +1,2 @@
-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 || [],
-    };
-}
-/**
- * Creates a pipeline that manages task execution with event-based dependencies.
- */
-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) => {
-                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;
-                }
-                console.error(`[builderman] Starting task: ${task.name}`);
-                // 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
-                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);
-                }
-                const newPath = binPaths.join(pathSeparator);
-                const env = {
-                    ...process.env,
-                    PATH: newPath,
-                    Path: newPath, // Windows uses both PATH and Path
-                };
-                // Use shell mode to allow commands like "vite dev" to work properly
-                const child = spawn(task.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);
-                    process.exitCode = 1;
-                    eventEmitter.emit("taskCompleted", task.name);
-                });
-                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"));
-                });
-            });
-        },
-    };
-}
+export * from "./task.js";
+export * from "./pipeline.js";

package/dist/pipeline.d.ts

@@ -0,0 +1,5 @@
+import type { Pipeline, Task } from "./types.js";
+/**
+ * Creates a pipeline that manages task execution with dependency-based coordination.
+ */
+export declare function pipeline(tasks: Task[]): Pipeline;

package/dist/pipeline.js

@@ -0,0 +1,187 @@
+import { spawn } from "node:child_process";
+import { EventEmitter } from "node:events";
+import * as path from "node:path";
+import { $TASK_INTERNAL } from "./constants.js";
+/**
+ * Creates a pipeline that manages task execution with dependency-based coordination.
+ */
+export function pipeline(tasks) {
+    return {
+        async run() {
+            const eventEmitter = new EventEmitter();
+            const runningTasks = new Map();
+            const completedTasks = new Set();
+            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[$TASK_INTERNAL].commands.build
+                    : task[$TASK_INTERNAL].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;
+                }
+                const { dependsOn: dependencies } = task[$TASK_INTERNAL];
+                if (!dependencies || dependencies.length === 0) {
+                    return true;
+                }
+                // Wait for all dependencies
+                for (const dep of dependencies) {
+                    if (typeof dep === "function") {
+                        await dep();
+                    }
+                    else {
+                        await dep;
+                    }
+                }
+                return true;
+            };
+            // Function to start a task
+            const startTask = async (task) => {
+                if (runningTasks.has(task.name)) {
+                    return;
+                }
+                const command = getCommand(task);
+                const { cwd, readyOn, markComplete, markReady } = task[$TASK_INTERNAL];
+                // Ensure node_modules/.bin is in PATH for local dependencies
+                const taskCwd = path.isAbsolute(cwd)
+                    ? cwd
+                    : path.resolve(process.cwd(), cwd);
+                const localBinPath = path.join(taskCwd, "node_modules", ".bin");
+                // Build PATH with local node_modules/.bin first
+                const existingPath = process.env.PATH || process.env.Path || "";
+                const pathSeparator = process.platform === "win32" ? ";" : ":";
+                const binPaths = [localBinPath];
+                const rootBinPath = path.join(process.cwd(), "node_modules", ".bin");
+                if (rootBinPath !== localBinPath) {
+                    binPaths.push(rootBinPath);
+                }
+                if (existingPath) {
+                    binPaths.push(existingPath);
+                }
+                const newPath = binPaths.join(pathSeparator);
+                const env = {
+                    ...process.env,
+                    PATH: newPath,
+                    Path: newPath,
+                };
+                // On Windows, use the shell from environment or default to cmd.exe
+                // In Git Bash, use bash instead
+                let shell = true;
+                if (process.platform === "win32") {
+                    // Check if we're in Git Bash (SHELL env var is set)
+                    if (process.env.SHELL && process.env.SHELL.includes("bash")) {
+                        shell = process.env.SHELL;
+                    }
+                    else {
+                        // Use ComSpec (cmd.exe) or fallback
+                        shell = process.env.ComSpec || "cmd.exe";
+                    }
+                }
+                const child = spawn(command, {
+                    cwd,
+                    stdio: ["inherit", "pipe", "pipe"],
+                    shell,
+                    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);
+                    markComplete();
+                    process.exitCode = 1;
+                    eventEmitter.emit("taskCompleted", task.name);
+                });
+                runningTasks.set(task.name, child);
+                // If task doesn't have readyOn, mark as ready immediately
+                if (!readyOn) {
+                    readyTasks.add(task.name);
+                    markReady();
+                    eventEmitter.emit("taskReady", task.name);
+                }
+                // Monitor stdout for readiness
+                let stdoutBuffer = "";
+                let allOutput = "";
+                child.stdout?.on("data", (data) => {
+                    const chunk = data.toString();
+                    allOutput += chunk;
+                    stdoutBuffer += chunk;
+                    const lines = stdoutBuffer.split("\n");
+                    stdoutBuffer = lines.pop() || "";
+                    for (const line of lines) {
+                        // Check if task is ready based on readyOn callback
+                        if (readyOn && !readyTasks.has(task.name)) {
+                            if (readyOn(allOutput)) {
+                                readyTasks.add(task.name);
+                                markReady();
+                                eventEmitter.emit("taskReady", task.name);
+                            }
+                        }
+                        // 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);
+                    markComplete();
+                    if (code !== 0) {
+                        process.exitCode = code || 1;
+                    }
+                    eventEmitter.emit("taskCompleted", task.name);
+                });
+            };
+            // Function to try starting tasks when dependencies are ready
+            const tryStartTasks = async () => {
+                for (const task of tasks) {
+                    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
+            await tryStartTasks();
+            // Wait for all tasks to complete
+            return new Promise((resolve, reject) => {
+                const checkCompletion = () => {
+                    if (runningTasks.size === 0) {
+                        resolve();
+                    }
+                };
+                eventEmitter.on("taskCompleted", checkCompletion);
+                checkCompletion();
+                // Handle process termination
+                process.on("SIGINT", () => {
+                    for (const child of runningTasks.values()) {
+                        child.kill("SIGINT");
+                    }
+                    reject(new Error("Process interrupted"));
+                });
+                process.on("SIGTERM", () => {
+                    for (const child of runningTasks.values()) {
+                        child.kill("SIGTERM");
+                    }
+                    reject(new Error("Process terminated"));
+                });
+            });
+        },
+    };
+}

package/dist/task.d.ts

@@ -0,0 +1,5 @@
+import type { TaskConfig, Task } from "./types.js";
+/**
+ * Creates a task configuration.
+ */
+export declare function task(config: TaskConfig): Task;

package/dist/task.js

@@ -0,0 +1,39 @@
+import { $TASK_INTERNAL } from "./constants.js";
+/**
+ * Creates a task configuration.
+ */
+export function task(config) {
+    let resolveReady = null;
+    const readyPromise = new Promise((resolve) => {
+        resolveReady = resolve;
+    });
+    let isReady = false;
+    let isComplete = false;
+    return {
+        name: config.name,
+        readyOrComplete() {
+            return readyPromise;
+        },
+        [$TASK_INTERNAL]: {
+            ...config,
+            dependsOn: config.dependsOn || [],
+            isReady: () => isReady,
+            isComplete: () => isComplete,
+            markReady: () => {
+                if (!isReady && resolveReady) {
+                    isReady = true;
+                    resolveReady();
+                }
+            },
+            markComplete: () => {
+                if (!isComplete) {
+                    isComplete = true;
+                    if (!isReady && resolveReady) {
+                        isReady = true;
+                        resolveReady();
+                    }
+                }
+            },
+        },
+    };
+}

package/dist/types.d.ts

@@ -0,0 +1,29 @@
+import type { $TASK_INTERNAL } from "./constants.js";
+export interface Commands {
+    dev: string;
+    build: string;
+}
+export interface TaskConfig {
+    name: string;
+    commands: Commands;
+    cwd: string;
+    readyOn?: (output: string) => boolean;
+    dependsOn?: Dependency[];
+}
+export type Dependency = Promise<void> | (() => Promise<void>);
+interface TaskInternal extends TaskConfig {
+    dependsOn: Dependency[];
+    isReady: () => boolean;
+    isComplete: () => boolean;
+    markReady: () => void;
+    markComplete: () => void;
+}
+export interface Task {
+    name: string;
+    readyOrComplete(): Promise<void>;
+    [$TASK_INTERNAL]: TaskInternal;
+}
+export interface Pipeline {
+    run(): Promise<void>;
+}
+export {};

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "builderman",
-  "version": "1.0.2",
-  "description": "An awesome new package",
+  "version": "1.0.4",
+  "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": {