builderman 1.0.3 → 1.0.5

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,26 +1,3 @@
-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>);
-export interface Task extends TaskConfig {
-    readyOrComplete(): Promise<void>;
-}
-export interface Pipeline {
-    run(): Promise<void>;
-}
-/**
- * Creates a task configuration.
- */
-export declare function task(config: TaskConfig): Task;
-/**
- * Creates a pipeline that manages task execution with dependency-based coordination.
- */
-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,205 +1,2 @@
-import { spawn } from "node:child_process";
-import { EventEmitter } from "node:events";
-import * as path from "node:path";
-/**
- * Creates a task configuration.
- */
-export function task(config) {
-    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 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.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;
-                }
-                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 = async (task) => {
-                if (runningTasks.has(task.name)) {
-                    return;
-                }
-                const command = getCommand(task);
-                // Ensure node_modules/.bin is in PATH for local dependencies
-                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
-                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,
-                };
-                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);
-                // 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) => {
-                    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 (task.readyOn && !readyTasks.has(task.name)) {
-                            if (task.readyOn(allOutput)) {
-                                readyTasks.add(task.name);
-                                task._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);
-                    task._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"));
-                });
-            });
-        },
-    };
-}
+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,184 @@
+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 cmd.exe explicitly to avoid path resolution issues
+                // Using shell: true can cause issues with Git Bash paths
+                const spawnOptions = {
+                    cwd,
+                    stdio: ["inherit", "pipe", "pipe"],
+                    env,
+                };
+                if (process.platform === "win32") {
+                    // Use cmd.exe explicitly on Windows
+                    spawnOptions.shell = process.env.ComSpec || "cmd.exe";
+                }
+                else {
+                    // On Unix-like systems, use shell: true
+                    spawnOptions.shell = true;
+                }
+                const child = spawn(command, spawnOptions);
+                // 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,6 +1,6 @@
 {
   "name": "builderman",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Simple task runner for building and developing projects.",
   "main": "dist/index.js",
   "type": "module",