@visulima/task-runner 1.0.0-alpha.2 → 1.0.0-alpha.4

package/dist/packem_shared/runConcurrentFallback-3q46z4AS.js

@@ -0,0 +1,357 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  spawn: spawn$1
+} = __cjs_getBuiltinModule("node:child_process");
+import { spawn } from '@lydell/node-pty';
+
+const evaluateSuccess = (events, condition) => {
+  if (events.length === 0) {
+    return true;
+  }
+  const normalized = condition.trim().toLowerCase();
+  if (normalized === "first") {
+    return events[0].exitCode === 0;
+  }
+  if (normalized === "last") {
+    return events.at(-1).exitCode === 0;
+  }
+  const commandMatch = /^(!?)command-(.+)$/.exec(normalized);
+  if (commandMatch) {
+    const [, negated, target] = commandMatch;
+    const isNegated = negated === "!";
+    const matching = events.filter((e) => e.name === target || String(e.index) === target);
+    if (isNegated) {
+      return events.filter((e) => !matching.includes(e)).every((e) => e.exitCode === 0);
+    }
+    return matching.length > 0 && matching.every((e) => e.exitCode === 0);
+  }
+  return events.every((e) => e.exitCode === 0);
+};
+const killTree = (pid, signal) => {
+  try {
+    if (process.platform === "win32") {
+      spawn$1("taskkill", ["/F", "/T", "/PID", String(pid)], { stdio: "ignore" });
+    } else {
+      process.kill(-pid, signal);
+    }
+  } catch {
+  }
+};
+const spawnCommand = (index, config, shellPath, onEvent, onComplete) => {
+  const startTime = process.hrtime();
+  const useShell = config.shell !== false;
+  const stdinMode = config.stdin ?? "null";
+  const stdinStdio = stdinMode === "inherit" ? "inherit" : stdinMode === "pipe" ? "pipe" : "ignore";
+  let child;
+  if (useShell) {
+    let shellProgram;
+    let shellArgs;
+    let verbatimArgs = false;
+    if (shellPath) {
+      shellProgram = shellPath;
+      shellArgs = ["-c", config.command];
+    } else if (process.platform === "win32") {
+      shellProgram = "cmd.exe";
+      shellArgs = ["/s", "/c", `"${config.command}"`];
+      verbatimArgs = true;
+    } else {
+      shellProgram = "/bin/sh";
+      shellArgs = ["-c", config.command];
+    }
+    child = spawn$1(shellProgram, shellArgs, {
+      cwd: config.cwd,
+      detached: process.platform !== "win32",
+      env: {
+        ...process.env,
+        ...config.env,
+        FORCE_COLOR: process.env["FORCE_COLOR"] ?? "1"
+      },
+      stdio: [stdinStdio, "pipe", "pipe"],
+      windowsVerbatimArguments: verbatimArgs
+    });
+  } else {
+    const parts = config.command.split(/\s+/);
+    const program = parts[0];
+    const args = parts.slice(1);
+    child = spawn$1(program, args, {
+      cwd: config.cwd,
+      detached: process.platform !== "win32",
+      env: {
+        ...process.env,
+        ...config.env,
+        FORCE_COLOR: process.env["FORCE_COLOR"] ?? "1"
+      },
+      stdio: [stdinStdio, "pipe", "pipe"]
+    });
+  }
+  onEvent({
+    index,
+    kill: child.pid ? (signal) => killTree(child.pid, signal ?? "SIGTERM") : void 0,
+    kind: "started",
+    write: child.stdin ? (data) => child.stdin.write(data) : void 0
+  });
+  let stdoutBuffer = "";
+  let stdoutFlushTimer;
+  const flushStdoutBuffer = () => {
+    if (stdoutBuffer) {
+      onEvent({ index, kind: "stdout", text: stdoutBuffer });
+      stdoutBuffer = "";
+    }
+  };
+  child.stdout?.on("data", (data) => {
+    if (stdoutFlushTimer) {
+      clearTimeout(stdoutFlushTimer);
+      stdoutFlushTimer = void 0;
+    }
+    stdoutBuffer += data.toString();
+    const lines = stdoutBuffer.split("\n");
+    stdoutBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      onEvent({ index, kind: "stdout", text: line });
+    }
+    if (stdoutBuffer) {
+      stdoutFlushTimer = setTimeout(flushStdoutBuffer, 100);
+    }
+  });
+  child.stdout?.on("end", () => {
+    if (stdoutFlushTimer) {
+      clearTimeout(stdoutFlushTimer);
+      stdoutFlushTimer = void 0;
+    }
+    flushStdoutBuffer();
+  });
+  let stderrBuffer = "";
+  let stderrFlushTimer;
+  const flushStderrBuffer = () => {
+    if (stderrBuffer) {
+      onEvent({ index, kind: "stderr", text: stderrBuffer });
+      stderrBuffer = "";
+    }
+  };
+  child.stderr?.on("data", (data) => {
+    if (stderrFlushTimer) {
+      clearTimeout(stderrFlushTimer);
+      stderrFlushTimer = void 0;
+    }
+    stderrBuffer += data.toString();
+    const lines = stderrBuffer.split("\n");
+    stderrBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      onEvent({ index, kind: "stderr", text: line });
+    }
+    if (stderrBuffer) {
+      stderrFlushTimer = setTimeout(flushStderrBuffer, 100);
+    }
+  });
+  child.stderr?.on("end", () => {
+    if (stderrFlushTimer) {
+      clearTimeout(stderrFlushTimer);
+      stderrFlushTimer = void 0;
+    }
+    flushStderrBuffer();
+  });
+  child.on("error", (error) => {
+    onEvent({ index, kind: "error", message: error.message });
+  });
+  child.on("close", (code, signal) => {
+    if (stdoutFlushTimer) {
+      clearTimeout(stdoutFlushTimer);
+      stdoutFlushTimer = void 0;
+    }
+    if (stderrFlushTimer) {
+      clearTimeout(stderrFlushTimer);
+      stderrFlushTimer = void 0;
+    }
+    flushStdoutBuffer();
+    flushStderrBuffer();
+    const elapsed = process.hrtime(startTime);
+    const durationMs = elapsed[0] * 1e3 + elapsed[1] / 1e6;
+    const exitCode = code ?? (signal ? 1 : -1);
+    const closeEvent = {
+      command: config.command,
+      durationMs,
+      exitCode,
+      index,
+      killed: signal !== null,
+      name: config.name
+    };
+    onEvent({
+      commandName: config.name,
+      durationMs,
+      exitCode,
+      index,
+      killed: signal !== null,
+      kind: "close"
+    });
+    onComplete(closeEvent);
+  });
+  return { child, index, startTime };
+};
+const spawnCommandPty = (index, config, shellPath, onEvent, onComplete) => {
+  const startTime = process.hrtime();
+  let shellProgram;
+  let shellArgs;
+  if (shellPath) {
+    shellProgram = shellPath;
+    shellArgs = ["-c", config.command];
+  } else if (process.platform === "win32") {
+    shellProgram = "cmd.exe";
+    shellArgs = ["/s", "/c", config.command];
+  } else {
+    shellProgram = "/bin/sh";
+    shellArgs = ["-c", config.command];
+  }
+  const ptyInstance = spawn(shellProgram, shellArgs, {
+    cols: config.ptySize?.cols ?? 80,
+    cwd: config.cwd ?? process.cwd(),
+    env: Object.fromEntries(
+      Object.entries({ ...process.env, ...config.env, FORCE_COLOR: process.env["FORCE_COLOR"] ?? "1", TERM: "xterm-256color" }).filter((entry) => entry[1] !== void 0)
+    ),
+    name: "xterm-256color",
+    rows: config.ptySize?.rows ?? 24
+  });
+  onEvent({
+    index,
+    kill: (signal) => ptyInstance.kill(signal),
+    kind: "started",
+    resize: (cols, rows) => ptyInstance.resize(cols, rows),
+    write: (data) => ptyInstance.write(data)
+  });
+  ptyInstance.onData((data) => {
+    onEvent({ index, kind: "stdout", text: data });
+  });
+  ptyInstance.onExit(({ exitCode, signal }) => {
+    const elapsed = process.hrtime(startTime);
+    const durationMs = elapsed[0] * 1e3 + elapsed[1] / 1e6;
+    const code = exitCode ?? (signal ? 1 : -1);
+    const closeEvent = {
+      command: config.command,
+      durationMs,
+      exitCode: code,
+      index,
+      killed: signal !== void 0 && signal !== 0,
+      name: config.name
+    };
+    onEvent({
+      commandName: config.name,
+      durationMs,
+      exitCode: code,
+      index,
+      killed: signal !== void 0 && signal !== 0,
+      kind: "close"
+    });
+    onComplete(closeEvent);
+  });
+  return { index, pty: ptyInstance, startTime };
+};
+const runConcurrentFallback = (commands, options) => new Promise((resolve) => {
+  if (commands.length === 0) {
+    resolve({ closeEvents: [], success: true });
+    return;
+  }
+  const maxProcesses = options.maxProcesses && options.maxProcesses > 0 ? options.maxProcesses : commands.length;
+  const killSignal = options.killSignal ?? "SIGTERM";
+  const killOthers = options.killOthers ?? [];
+  const successCondition = options.successCondition ?? "all";
+  const onEvent = options.onEvent ?? (() => {
+  });
+  const active = [];
+  const closeEvents = [];
+  const pending = commands.map((_, i) => i);
+  let aborting = false;
+  let sigintAbort = false;
+  const killAll = () => {
+    for (const proc of active) {
+      if (proc.pty) {
+        proc.pty.kill(killSignal);
+      } else if (proc.child?.pid) {
+        killTree(proc.child.pid, killSignal);
+      }
+    }
+  };
+  const shouldKillOthers = (event) => {
+    for (const condition of killOthers) {
+      if (condition === "failure" && event.exitCode !== 0) {
+        return true;
+      }
+      if (condition === "success" && event.exitCode === 0) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const handleClose = (cmdIndex, closeEvent) => {
+    const activeIndex = active.findIndex((p) => p.index === cmdIndex);
+    if (activeIndex !== -1) {
+      active.splice(activeIndex, 1);
+    }
+    if (aborting) {
+      closeEvent.killed = true;
+      if (sigintAbort) {
+        closeEvent.exitCode = 0;
+      }
+    }
+    closeEvents.push(closeEvent);
+    if (!aborting && shouldKillOthers(closeEvent)) {
+      aborting = true;
+      killAll();
+    }
+    if (!aborting) {
+      maybeSpawnMore();
+    }
+    if (active.length === 0 && pending.length === 0) {
+      const success = evaluateSuccess(closeEvents, successCondition);
+      resolve({ closeEvents, success });
+    }
+  };
+  const maybeSpawnMore = () => {
+    while (active.length < maxProcesses && pending.length > 0) {
+      const cmdIndex = pending.shift();
+      const config = commands[cmdIndex];
+      const proc = config.stdin === "pty" ? spawnCommandPty(cmdIndex, config, options.shellPath, onEvent, (ce) => handleClose(cmdIndex, ce)) : spawnCommand(cmdIndex, config, options.shellPath, onEvent, (ce) => handleClose(cmdIndex, ce));
+      active.push(proc);
+    }
+  };
+  const handleSigint = () => {
+    if (!aborting) {
+      aborting = true;
+      sigintAbort = true;
+      killAll();
+    }
+  };
+  const handleSigterm = () => {
+    if (!aborting) {
+      aborting = true;
+      killAll();
+    }
+  };
+  process.on("SIGINT", handleSigint);
+  process.on("SIGTERM", handleSigterm);
+  const originalResolve = resolve;
+  resolve = ((result) => {
+    process.removeListener("SIGINT", handleSigint);
+    process.removeListener("SIGTERM", handleSigterm);
+    originalResolve(result);
+  });
+  maybeSpawnMore();
+});
+
+export { runConcurrentFallback };

package/dist/packem_shared/runConcurrently-ATDwJNR6.js

@@ -0,0 +1,67 @@
+import { runConcurrentFallback } from './runConcurrentFallback-3q46z4AS.js';
+import { detectScriptShell } from './detectScriptShell-CR-xXKA4.js';
+import { logTimings } from './formatTimingTable-3qtCM552.js';
+import { withRestart } from './withRestart-BREjRJa4.js';
+import { runTeardown } from './runTeardown-BAezH79J.js';
+import { loadNativeBindings } from './isNativeAvailable-BpD28A6Z.js';
+
+const normalizeCommands = (inputs) => inputs.map((input) => {
+  if (typeof input === "string") {
+    return { command: input };
+  }
+  return input;
+});
+const coreRun = async (configs, options) => {
+  const shellPath = options.shellPath ?? detectScriptShell();
+  const native = loadNativeBindings();
+  const needsJsFallback = configs.some((c) => c.stdin === "pipe" || c.stdin === "pty") || !!options.onEvent;
+  if (native && !needsJsFallback) {
+    const nativeOptions = {
+      killOthers: options.killOthers,
+      killSignal: options.killSignal,
+      killTimeout: options.killTimeout,
+      maxProcesses: options.maxProcesses,
+      shellPath,
+      successCondition: options.successCondition
+    };
+    const nativeCommands = configs.map((c) => {
+      return {
+        command: c.command,
+        cwd: c.cwd,
+        env: c.env,
+        name: c.name,
+        shell: c.shell,
+        stdin: c.stdin
+      };
+    });
+    return native.runConcurrentBatch(nativeCommands, nativeOptions);
+  }
+  return runConcurrentFallback(configs, { ...options, shellPath });
+};
+const runConcurrently = async (commands, options = {}) => {
+  const configs = normalizeCommands(commands);
+  if (configs.length === 0) {
+    return { closeEvents: [], success: true };
+  }
+  let result;
+  if (options.restart && options.restart.tries !== 0) {
+    result = await withRestart((cmds, options_) => coreRun(cmds, options_), configs, options, {
+      delay: options.restart.delay ?? 0,
+      tries: options.restart.tries
+    });
+  } else {
+    result = await coreRun(configs, options);
+  }
+  if (options.timings) {
+    logTimings(result.closeEvents);
+  }
+  if (options.teardown && options.teardown.length > 0) {
+    await runTeardown({
+      commands: options.teardown,
+      cwd: options.teardownCwd
+    });
+  }
+  return result;
+};
+
+export { runConcurrently };

package/dist/packem_shared/runTeardown-BAezH79J.js

@@ -0,0 +1,49 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  spawn
+} = __cjs_getBuiltinModule("node:child_process");
+
+const runTeardown = async (options) => {
+  const { commands, cwd } = options;
+  const results = [];
+  for (const command of commands) {
+    const code = await runTeardownCommand(command, cwd);
+    results.push(code);
+  }
+  return results;
+};
+const runTeardownCommand = (command, cwd) => new Promise((resolve) => {
+  const shellProgram = process.platform === "win32" ? "cmd.exe" : "/bin/sh";
+  const shellArgs = process.platform === "win32" ? ["/s", "/c", `"${command}"`] : ["-c", command];
+  const child = spawn(shellProgram, shellArgs, {
+    cwd,
+    stdio: "inherit",
+    windowsVerbatimArguments: process.platform === "win32"
+  });
+  child.on("close", (code) => {
+    resolve(code ?? 1);
+  });
+  child.on("error", () => {
+    resolve(1);
+  });
+});
+
+export { runTeardown };

package/dist/packem_shared/stripQuotes-Cey-zwFf.js

@@ -0,0 +1,9 @@
+const stripQuotes = (config) => {
+  const { command } = config;
+  if (/^".+?"$/.test(command) || /^'.+?'$/.test(command)) {
+    return { ...config, command: command.slice(1, -1) };
+  }
+  return config;
+};
+
+export { stripQuotes };

package/dist/packem_shared/withRestart-BREjRJa4.js

@@ -0,0 +1,49 @@
+const withRestart = async (runFunction, commands, options, restartOptions) => {
+  const { delay, tries } = restartOptions;
+  if (tries === 0) {
+    return runFunction(commands, options);
+  }
+  const state = /* @__PURE__ */ new Map();
+  const allCloseEvents = [];
+  const userOnEvent = options.onEvent;
+  let pendingRestarts = [...commands];
+  let iteration = 0;
+  while (pendingRestarts.length > 0) {
+    const currentBatch = pendingRestarts;
+    pendingRestarts = [];
+    const result = await runFunction(currentBatch, {
+      ...options,
+      onEvent: (event) => {
+        userOnEvent?.(event);
+      }
+    });
+    for (const closeEvent of result.closeEvents) {
+      if (closeEvent.exitCode !== 0) {
+        const cmdState = state.get(closeEvent.index) ?? { attempts: 0, commandIndex: closeEvent.index };
+        cmdState.attempts++;
+        state.set(closeEvent.index, cmdState);
+        const shouldRestart = tries === -1 || cmdState.attempts <= tries;
+        if (shouldRestart) {
+          const delayMs = delay === "exponential" ? Math.min(2 ** (cmdState.attempts - 1) * 1e3, 3e4) : delay;
+          if (delayMs > 0) {
+            await sleep(delayMs);
+          }
+          pendingRestarts.push(currentBatch[closeEvent.index]);
+          continue;
+        }
+      }
+      allCloseEvents.push(closeEvent);
+    }
+    iteration++;
+    if (iteration > 1e3) {
+      break;
+    }
+  }
+  const success = allCloseEvents.every((e) => e.exitCode === 0);
+  return { closeEvents: allCloseEvents, success };
+};
+const sleep = (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+
+export { withRestart };

package/dist/project-constraints.d.ts

@@ -0,0 +1,16 @@
+import type { ConstraintsConfig, ConstraintViolation, ProjectGraph } from "./types.d.ts";
+/**
+ * Enforces project dependency constraints on a project graph.
+ * Returns an array of violations found. Does not throw — the caller
+ * decides how to handle violations (fatal error, warning, etc.).
+ *
+ * Three constraint mechanisms:
+ * 1. **Tag relationships**: If a project has a tag listed in `tagRelationships`,
+ *    its dependencies must have at least one of the required tags.
+ * 2. **Type boundaries**: Controls which project types can depend on which.
+ *    By default, no project may depend on an "application" type project.
+ * 3. **Dependency kind rules**: Controls rules based on whether the dependency
+ *    is a production dependency, devDependency, or peerDependency.
+ */
+declare const enforceProjectConstraints: (projectGraph: ProjectGraph, constraints: ConstraintsConfig) => ConstraintViolation[];
+export { enforceProjectConstraints };

package/dist/task-scheduler.d.ts

@@ -1,10 +1,33 @@
 import type { ProjectGraph, Task, TaskGraph } from "./types.d.ts";
+/**
+ * Options for partitioning tasks across CI runners.
+ */
+export interface PartitionOptions {
+    /** 1-based partition index (e.g., 1 for the first partition) */
+    index: number;
+    /** Total number of partitions */
+    total: number;
+}
+/**
+ * Parses a partition string like "1/4" into PartitionOptions.
+ * Also supports the VIS_PARTITION environment variable as fallback.
+ */
+export declare const parsePartition: (value?: string) => PartitionOptions | undefined;
 /**
  * Manages the scheduling order of tasks based on dependencies,
  * parallelism constraints, and estimated execution times.
  */
 export declare class TaskScheduler {
     #private;
+    /**
+     * Partitions a list of tasks for distributed CI execution.
+     * Tasks are sorted by ID for deterministic distribution, then split
+     * using ceiling division so partitions differ by at most one task.
+     * @param tasks The full list of tasks to partition
+     * @param partition The partition configuration (1-based index and total)
+     * @returns The subset of tasks assigned to this partition
+     */
+    static partitionTasks(tasks: Task[], partition: PartitionOptions): Task[];
     constructor(taskGraph: TaskGraph, projectGraph: ProjectGraph, maxParallel?: number);
     /**
      * Returns the next batch of tasks that are ready to execute.

package/dist/terminal-buffer.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal virtual terminal buffer that processes ANSI escape sequences
+ * for cursor movement and line erasure. This allows PTY output from
+ * interactive tools (inquirer, etc.) to render correctly by updating
+ * lines in place rather than always appending.
+ *
+ * Supported sequences:
+ * - \r       carriage return (cursor to column 0)
+ * - \n       line feed (new line)
+ * - \x1b[nA  cursor up n lines
+ * - \x1b[nB  cursor down n lines
+ * - \x1b[nC  cursor forward n columns
+ * - \x1b[nD  cursor back n columns
+ * - \x1b[nG  cursor to column n
+ * - \x1b[r;cH cursor position
+ * - \x1b[K   erase from cursor to end of line (0K, 1K, 2K)
+ * - \x1b[J   erase from cursor to end of display (0J, 1J, 2J)
+ * - \x1b[...m SGR (colors/styles) — passed through into output
+ */
+export declare class TerminalBuffer {
+    #private;
+    constructor(maxBytes?: number);
+    /**
+     * Process raw PTY output data.
+     */
+    write(data: string): void;
+    /** Get the current buffer content as a string. */
+    toString(): string;
+}