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

package/dist/packem_shared/TaskOrchestrator-BvYs3ONw.js

@@ -0,0 +1,342 @@
+import { d as resolveTaskCwd, a as createFailureResult, e as createXxh3Hasher } from './utils-zO0ZRgtf.js';
+import { join } from '@visulima/path';
+import { FingerprintManager } from './FingerprintManager-D6Y0erg-.js';
+import { generateRunSummary, writeRunSummary } from './generateRunSummary-qn-_jKwt.js';
+import { computeTaskHash } from './computeTaskHash-BoCnnvIJ.js';
+import { TrackedTaskExecutor } from './TrackedTaskExecutor-BGUKFE-7.js';
+
+const hashFingerprint = (fingerprint) => {
+  const hash = createXxh3Hasher();
+  hash.update(fingerprint.commandHash);
+  for (const key of Object.keys(fingerprint.fileHashes).toSorted()) {
+    hash.update(key);
+    hash.update(fingerprint.fileHashes[key]);
+  }
+  for (const path of fingerprint.missingFiles) {
+    hash.update(`missing:${path}`);
+  }
+  for (const key of Object.keys(fingerprint.directoryListings).toSorted()) {
+    hash.update(`dir:${key}`);
+    hash.update(JSON.stringify(fingerprint.directoryListings[key]));
+  }
+  for (const key of Object.keys(fingerprint.envHashes).toSorted()) {
+    hash.update(key);
+    hash.update(fingerprint.envHashes[key]);
+  }
+  return hash.digest();
+};
+const createDeferred = () => {
+  let resolve;
+  const promise = new Promise((r) => {
+    resolve = r;
+  });
+  return { promise, resolve };
+};
+class TaskOrchestrator {
+  #taskHasher;
+  #cache;
+  #scheduler;
+  #lifeCycle;
+  #taskExecutor;
+  #workspaceRoot;
+  #skipCache;
+  #captureOutput;
+  #autoFingerprint;
+  #fingerprintManager;
+  #trackedExecutor;
+  #fingerprintEnvPatterns;
+  #untrackedEnvVars;
+  #cacheDiagnostics;
+  #resolveCommand;
+  #remoteCache;
+  #dryRun;
+  #summarize;
+  #taskGraph;
+  #results = /* @__PURE__ */ new Map();
+  #startTime;
+  /** Tracks in-flight task promises so the execution loop can await them */
+  #inFlightTasks = /* @__PURE__ */ new Map();
+  /** Deferred that gets resolved whenever a task completes, waking the loop */
+  #taskCompletionSignal = createDeferred();
+  #aborted = false;
+  constructor(options) {
+    this.#taskHasher = options.taskHasher;
+    this.#cache = options.cache;
+    this.#scheduler = options.scheduler;
+    this.#lifeCycle = options.lifeCycle;
+    this.#taskExecutor = options.taskExecutor;
+    this.#workspaceRoot = options.workspaceRoot;
+    this.#skipCache = options.skipCache ?? false;
+    this.#captureOutput = options.captureOutput ?? true;
+    this.#autoFingerprint = options.autoFingerprint ?? false;
+    this.#fingerprintEnvPatterns = options.fingerprintEnvPatterns ?? [];
+    this.#untrackedEnvVars = options.untrackedEnvVars ?? [];
+    this.#cacheDiagnostics = options.cacheDiagnostics ?? false;
+    this.#resolveCommand = options.resolveCommand ?? void 0;
+    this.#remoteCache = options.remoteCache ?? void 0;
+    this.#dryRun = options.dryRun ?? false;
+    this.#summarize = options.summarize ?? false;
+    this.#taskGraph = options.taskGraph ?? void 0;
+    this.#startTime = Date.now();
+    if (this.#autoFingerprint) {
+      this.#fingerprintManager = new FingerprintManager(options.workspaceRoot);
+      this.#trackedExecutor = new TrackedTaskExecutor(options.workspaceRoot);
+    } else {
+      this.#fingerprintManager = void 0;
+      this.#trackedExecutor = void 0;
+    }
+  }
+  async run() {
+    this.#lifeCycle.startCommand?.();
+    const signalHandler = () => {
+      this.#aborted = true;
+      this.#trackedExecutor?.killAll();
+    };
+    process.on("SIGINT", signalHandler);
+    process.on("SIGTERM", signalHandler);
+    try {
+      await this.#executionLoop();
+    } finally {
+      process.removeListener("SIGINT", signalHandler);
+      process.removeListener("SIGTERM", signalHandler);
+      this.#lifeCycle.endCommand?.();
+    }
+    if (this.#summarize && this.#taskGraph) {
+      const summary = generateRunSummary(this.#results, this.#taskGraph, this.#startTime);
+      await writeRunSummary(summary, this.#workspaceRoot);
+    }
+    return this.#results;
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  async #executionLoop() {
+    while (!this.#scheduler.isComplete() && !this.#aborted) {
+      const batch = this.#scheduler.getNextBatch();
+      if (batch.length === 0) {
+        if (this.#inFlightTasks.size > 0) {
+          await this.#taskCompletionSignal.promise;
+          this.#taskCompletionSignal = createDeferred();
+          continue;
+        }
+        if (this.#scheduler.remainingCount > 0) {
+          throw new Error("Deadlock detected: tasks remain but none can be scheduled. This may indicate a circular dependency.");
+        }
+        break;
+      }
+      for (const task of batch) {
+        this.#lifeCycle.scheduleTask?.(task);
+        this.#scheduler.startTask(task.id);
+      }
+      this.#lifeCycle.startTasks?.(batch);
+      for (const task of batch) {
+        const taskPromise = (this.#autoFingerprint ? this.#processTaskWithFingerprint(task) : this.#processTask(task)).catch((error) => {
+          const errorResult = createFailureResult(task, error, Date.now());
+          this.#results.set(task.id, errorResult);
+          return errorResult;
+        }).then((result) => {
+          this.#inFlightTasks.delete(task.id);
+          this.#scheduler.completeTask(task.id);
+          this.#lifeCycle.endTasks?.([result]);
+          if (result.terminalOutput) {
+            this.#lifeCycle.printTaskTerminalOutput?.(result.task, result.status, result.terminalOutput);
+          }
+          this.#taskCompletionSignal.resolve();
+          return result;
+        });
+        this.#inFlightTasks.set(task.id, taskPromise);
+      }
+      if (this.#inFlightTasks.size > 0) {
+        await this.#taskCompletionSignal.promise;
+        this.#taskCompletionSignal = createDeferred();
+      }
+    }
+    if (this.#inFlightTasks.size > 0) {
+      await Promise.all(this.#inFlightTasks.values());
+    }
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  async #processTask(task) {
+    const startTime = Date.now();
+    const hashDetails = await this.#taskHasher.hashTask(task);
+    const hash = computeTaskHash(hashDetails);
+    Object.assign(task, { hash, hashDetails });
+    if (this.#dryRun) {
+      return this.#dryRunResult(task, startTime);
+    }
+    if (!this.#skipCache && task.cache !== false) {
+      const cachedResult = await this.#cache.get(hash);
+      if (cachedResult) {
+        return this.#applyCachedResult(task, cachedResult, startTime);
+      }
+      if (this.#remoteCache) {
+        const retrieved = await this.#remoteCache.retrieve(hash, this.#cache.cacheDirectory);
+        if (retrieved) {
+          const remoteCached = await this.#cache.get(hash);
+          if (remoteCached) {
+            const result2 = await this.#applyCachedResult(task, remoteCached, startTime);
+            result2.status = "remote-cache";
+            return result2;
+          }
+        }
+      }
+    }
+    const result = await this.#executeTask(task, startTime);
+    if (result.code === 0 && task.cache !== false && task.hash && this.#remoteCache) {
+      this.#remoteCache.store(task.hash, this.#cache.cacheDirectory).catch(() => {
+      });
+    }
+    return result;
+  }
+  // eslint-disable-next-line sonarjs/cognitive-complexity
+  async #processTaskWithFingerprint(task) {
+    const startTime = Date.now();
+    if (!this.#skipCache && task.cache !== false) {
+      const cachedResult = await this.#cache.getByTaskId(task.id);
+      if (cachedResult?.fingerprint && this.#fingerprintManager) {
+        const commandMiss = this.#fingerprintManager.validateCommand(
+          cachedResult.fingerprint,
+          `${task.target.project}:${task.target.target}`,
+          task.overrides
+        );
+        if (commandMiss) {
+          if (this.#cacheDiagnostics) {
+            this.#lifeCycle.printCacheMiss?.(task, this.#fingerprintManager.formatMissReasons([commandMiss]));
+          }
+        } else {
+          const missReasons = await this.#fingerprintManager.validate(cachedResult.fingerprint);
+          if (!missReasons) {
+            return this.#applyCachedResult(task, cachedResult, startTime);
+          }
+          if (this.#cacheDiagnostics) {
+            this.#lifeCycle.printCacheMiss?.(task, this.#fingerprintManager.formatMissReasons(missReasons));
+          }
+        }
+      } else if (this.#cacheDiagnostics && !cachedResult) {
+        this.#lifeCycle.printCacheMiss?.(task, "Cache miss reasons:\n  - No previous fingerprint found (first run)");
+      }
+    }
+    return this.#executeTaskWithTracking(task, startTime);
+  }
+  async #applyCachedResult(task, cachedResult, startTime) {
+    const restored = await this.#cache.restoreOutputs(cachedResult.hash, task.outputs);
+    const status = restored ? "local-cache" : "local-cache-kept-existing";
+    const result = {
+      code: cachedResult.code,
+      endTime: Date.now(),
+      startTime,
+      status,
+      task,
+      terminalOutput: cachedResult.terminalOutput
+    };
+    this.#results.set(task.id, result);
+    return result;
+  }
+  async #executeTask(task, startTime) {
+    try {
+      const { code, terminalOutput } = await this.#taskExecutor(task, {
+        captureOutput: this.#captureOutput,
+        cwd: resolveTaskCwd(this.#workspaceRoot, task)
+      });
+      const result = {
+        code,
+        endTime: Date.now(),
+        startTime,
+        status: code === 0 ? "success" : "failure",
+        task,
+        terminalOutput
+      };
+      this.#results.set(task.id, result);
+      if (code === 0 && task.cache !== false && task.hash) {
+        await this.#cache.put(task.hash, terminalOutput, task.outputs, code);
+      }
+      return result;
+    } catch (error) {
+      const result = createFailureResult(task, error, startTime);
+      this.#results.set(task.id, result);
+      return result;
+    }
+  }
+  async #executeTaskWithTracking(task, startTime) {
+    if (!this.#fingerprintManager) {
+      return this.#executeTask(task, startTime);
+    }
+    const taskCommand = `${task.target.project}:${task.target.target}`;
+    const cwd = resolveTaskCwd(this.#workspaceRoot, task);
+    try {
+      let code;
+      let terminalOutput;
+      let fingerprint;
+      const shellCommand = this.#resolveCommand?.(task);
+      const canTrack = shellCommand && this.#trackedExecutor?.isTrackingSupported;
+      if (canTrack && this.#trackedExecutor) {
+        const trackedResult = await this.#trackedExecutor.execute(task, { captureOutput: this.#captureOutput, cwd }, shellCommand);
+        code = trackedResult.code;
+        terminalOutput = trackedResult.terminalOutput;
+        fingerprint = await this.#fingerprintManager.createFingerprint(
+          trackedResult.accesses,
+          taskCommand,
+          task.overrides,
+          process.env,
+          this.#fingerprintEnvPatterns,
+          this.#untrackedEnvVars
+        );
+      } else {
+        const executionResult = await this.#taskExecutor(task, {
+          captureOutput: this.#captureOutput,
+          cwd
+        });
+        code = executionResult.code;
+        terminalOutput = executionResult.terminalOutput;
+        const hashDetails = await this.#taskHasher.hashTask(task);
+        const fileAccesses = Object.keys(hashDetails.nodes).map((filePath) => {
+          return {
+            path: join(this.#workspaceRoot, filePath),
+            type: "read"
+          };
+        });
+        fingerprint = await this.#fingerprintManager.createFingerprint(
+          fileAccesses,
+          taskCommand,
+          task.overrides,
+          process.env,
+          this.#fingerprintEnvPatterns,
+          this.#untrackedEnvVars
+        );
+      }
+      const result = {
+        code,
+        endTime: Date.now(),
+        startTime,
+        status: code === 0 ? "success" : "failure",
+        task,
+        terminalOutput
+      };
+      this.#results.set(task.id, result);
+      if (code === 0 && task.cache !== false && fingerprint) {
+        const hash = hashFingerprint(fingerprint);
+        Object.assign(task, { hash });
+        await this.#cache.put(hash, terminalOutput, task.outputs, code, fingerprint);
+        await this.#cache.setTaskIndex(task.id, hash);
+      }
+      return result;
+    } catch (error) {
+      const result = createFailureResult(task, error, startTime);
+      this.#results.set(task.id, result);
+      return result;
+    }
+  }
+  #dryRunResult(task, startTime) {
+    const cacheStatus = task.hash ? `[hash: ${task.hash.slice(0, 12)}...]` : "[no hash]";
+    const result = {
+      code: 0,
+      endTime: Date.now(),
+      startTime,
+      status: "skipped",
+      task,
+      terminalOutput: `DRY RUN ${cacheStatus}`
+    };
+    this.#results.set(task.id, result);
+    return result;
+  }
+}
+
+export { TaskOrchestrator };

package/dist/packem_shared/TaskScheduler-CJilHDta.js

@@ -0,0 +1,111 @@
+const calculateProjectDepths = (projectGraph) => {
+  const depths = /* @__PURE__ */ new Map();
+  const visited = /* @__PURE__ */ new Set();
+  const calculateDepth = (projectName) => {
+    if (depths.has(projectName)) {
+      return depths.get(projectName);
+    }
+    if (visited.has(projectName)) {
+      return 0;
+    }
+    visited.add(projectName);
+    const deps = projectGraph.dependencies[projectName] ?? [];
+    let maxDepth = 0;
+    for (const dep of deps) {
+      maxDepth = Math.max(maxDepth, calculateDepth(dep.target) + 1);
+    }
+    depths.set(projectName, maxDepth);
+    visited.delete(projectName);
+    return maxDepth;
+  };
+  for (const projectName of Object.keys(projectGraph.nodes)) {
+    calculateDepth(projectName);
+  }
+  return depths;
+};
+class TaskScheduler {
+  #taskGraph;
+  #maxParallel;
+  #completedTasks = /* @__PURE__ */ new Set();
+  #runningTasks = /* @__PURE__ */ new Set();
+  #totalTasks;
+  #dependentCounts;
+  #projectDepths;
+  constructor(taskGraph, projectGraph, maxParallel = 3) {
+    this.#taskGraph = taskGraph;
+    this.#maxParallel = maxParallel;
+    this.#totalTasks = Object.keys(taskGraph.tasks).length;
+    this.#dependentCounts = this.#calculateDependentCounts();
+    this.#projectDepths = calculateProjectDepths(projectGraph);
+  }
+  /**
+   * Returns the next batch of tasks that are ready to execute.
+   */
+  getNextBatch() {
+    const availableSlots = this.#maxParallel - this.#runningTasks.size;
+    if (availableSlots <= 0) {
+      return [];
+    }
+    const readyTasks = this.#getReadyTasks();
+    const sortedTasks = this.#sortByPriority(readyTasks);
+    return sortedTasks.slice(0, availableSlots);
+  }
+  startTask(taskId) {
+    this.#runningTasks.add(taskId);
+  }
+  completeTask(taskId) {
+    this.#runningTasks.delete(taskId);
+    this.#completedTasks.add(taskId);
+  }
+  isComplete() {
+    return this.#completedTasks.size === this.#totalTasks;
+  }
+  get remainingCount() {
+    return this.#totalTasks - this.#completedTasks.size;
+  }
+  get runningCount() {
+    return this.#runningTasks.size;
+  }
+  #getReadyTasks() {
+    const ready = [];
+    for (const [taskId, task] of Object.entries(this.#taskGraph.tasks)) {
+      if (this.#completedTasks.has(taskId) || this.#runningTasks.has(taskId)) {
+        continue;
+      }
+      const deps = this.#taskGraph.dependencies[taskId] ?? [];
+      if (deps.every((dep) => this.#completedTasks.has(dep))) {
+        ready.push(task);
+      }
+    }
+    return ready;
+  }
+  #sortByPriority(tasks) {
+    return [...tasks].toSorted((a, b) => {
+      const aDeps = this.#dependentCounts.get(a.id) ?? 0;
+      const bDeps = this.#dependentCounts.get(b.id) ?? 0;
+      if (aDeps !== bDeps) {
+        return bDeps - aDeps;
+      }
+      const aDepth = this.#projectDepths.get(a.target.project) ?? 0;
+      const bDepth = this.#projectDepths.get(b.target.project) ?? 0;
+      if (aDepth !== bDepth) {
+        return bDepth - aDepth;
+      }
+      return a.id.localeCompare(b.id);
+    });
+  }
+  #calculateDependentCounts() {
+    const counts = /* @__PURE__ */ new Map();
+    for (const taskId of Object.keys(this.#taskGraph.tasks)) {
+      counts.set(taskId, 0);
+    }
+    for (const deps of Object.values(this.#taskGraph.dependencies)) {
+      for (const dep of deps) {
+        counts.set(dep, (counts.get(dep) ?? 0) + 1);
+      }
+    }
+    return counts;
+  }
+}
+
+export { TaskScheduler };

package/dist/packem_shared/TrackedTaskExecutor-BGUKFE-7.js

@@ -0,0 +1,164 @@
+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 {
+  exec
+} = __cjs_getBuiltinModule("node:child_process");
+const {
+  mkdir,
+  writeFile,
+  readFile,
+  rm
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { join } from '@visulima/path';
+import { FileAccessTracker, generatePreloadScript } from './FileAccessTracker-CrtBAt5D.js';
+import { u as uniqueId } from './utils-zO0ZRgtf.js';
+
+class TrackedTaskExecutor {
+  #tracker;
+  #workspaceRoot;
+  /** Tracks active child processes for cleanup on abort */
+  #activeProcesses = /* @__PURE__ */ new Set();
+  constructor(workspaceRoot) {
+    this.#workspaceRoot = workspaceRoot;
+    this.#tracker = new FileAccessTracker(workspaceRoot);
+  }
+  /**
+   * Returns true if file access tracking is supported on the current platform.
+   * strace tracking (Linux) or preload script (any Node.js process).
+   */
+  // eslint-disable-next-line class-methods-use-this
+  get isTrackingSupported() {
+    return true;
+  }
+  /**
+   * Returns true if the platform supports full syscall-level tracking (strace).
+   */
+  get isStraceSupported() {
+    return this.#tracker.isSupported();
+  }
+  /**
+   * Executes a task command and tracks all file system accesses.
+   *
+   * On Linux, uses strace for comprehensive tracking.
+   * On other platforms, uses a Node.js preload script (for Node processes).
+   */
+  async execute(task, options, command) {
+    const cwd = options.cwd ?? (task.projectRoot ? join(this.#workspaceRoot, task.projectRoot) : this.#workspaceRoot);
+    if (this.#tracker.isSupported()) {
+      const trackingResult = await this.#tracker.track(command, {
+        cwd,
+        env: options.env
+      });
+      return {
+        accesses: trackingResult.accesses,
+        code: trackingResult.code,
+        terminalOutput: trackingResult.output
+      };
+    }
+    return this.#executeWithPreload(command, cwd, options.env);
+  }
+  /**
+   * Executes a command with a Node.js preload script to track fs accesses.
+   * Works on macOS, Windows, and Linux for Node.js-based commands.
+   */
+  async #executeWithPreload(command, cwd, env) {
+    const cacheDirectory = join(this.#workspaceRoot, "node_modules", ".cache", "task-runner");
+    await mkdir(cacheDirectory, { recursive: true });
+    const id = uniqueId();
+    const logFile = join(cacheDirectory, `preload-${id}.log`);
+    const preloadFile = join(cacheDirectory, `preload-${id}.mjs`);
+    const scriptContent = generatePreloadScript(logFile);
+    await writeFile(preloadFile, scriptContent);
+    return new Promise((resolve) => {
+      const child = exec(
+        command,
+        {
+          cwd,
+          env: {
+            ...process.env,
+            ...env,
+            NODE_OPTIONS: `${process.env["NODE_OPTIONS"] ?? ""} --import ${preloadFile}`.trim()
+          },
+          maxBuffer: 50 * 1024 * 1024
+        },
+        async (_error, stdout, stderr) => {
+          this.#activeProcesses.delete(child);
+          let accesses = [];
+          try {
+            const logContent = await readFile(logFile, "utf8");
+            accesses = this.#parsePreloadLog(logContent);
+          } catch {
+          }
+          await rm(logFile, { force: true }).catch(() => {
+          });
+          await rm(preloadFile, { force: true }).catch(() => {
+          });
+          resolve({
+            accesses,
+            code: child.exitCode ?? 1,
+            terminalOutput: stdout + stderr
+          });
+        }
+      );
+      this.#activeProcesses.add(child);
+    });
+  }
+  /**
+   * Kills all active child processes. Called on abort/signal to prevent orphans.
+   */
+  killAll() {
+    this.#tracker.killAll();
+    for (const child of this.#activeProcesses) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+    }
+    this.#activeProcesses.clear();
+  }
+  /**
+   * Parses the JSON-lines log produced by the preload script.
+   */
+  #parsePreloadLog(content) {
+    const accesses = [];
+    const seen = /* @__PURE__ */ new Set();
+    for (const line of content.split("\n")) {
+      if (!line.trim()) {
+        continue;
+      }
+      try {
+        const entry = JSON.parse(line);
+        if (entry.path && !seen.has(entry.path)) {
+          seen.add(entry.path);
+          if (entry.path.startsWith(this.#workspaceRoot)) {
+            accesses.push({
+              path: entry.path,
+              type: entry.type
+            });
+          }
+        }
+      } catch {
+      }
+    }
+    return accesses;
+  }
+}
+
+export { TrackedTaskExecutor };

package/dist/packem_shared/collectFiles-ClXHnHhg.js

@@ -0,0 +1,22 @@
+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);
+};
+
+
+export { c as collectFiles, a as createFailureResult, h as hashFile, b as hashStrings, r as readPackageDeps, d as resolveTaskCwd, s as sortObjectKeys, u as uniqueId } from './utils-zO0ZRgtf.js';
+import '@visulima/path';