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

package/dist/packem_shared/RemoteCache-BDqrnDEi.js

@@ -1,179 +0,0 @@
-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 {
-  execFile
-} = __cjs_getBuiltinModule("node:child_process");
-const {
-  createWriteStream
-} = __cjs_getBuiltinModule("node:fs");
-const {
-  mkdir,
-  rm,
-  stat,
-  readFile
-} = __cjs_getBuiltinModule("node:fs/promises");
-import { join } from '@visulima/path';
-const {
-  pipeline
-} = __cjs_getBuiltinModule("node:stream/promises");
-
-const createTarGz = (sourceDirectory, outputPath) => new Promise((resolve, reject) => {
-  execFile("tar", ["-czf", outputPath, "-C", sourceDirectory, "."], (error) => {
-    if (error) {
-      reject(error);
-    } else {
-      resolve();
-    }
-  });
-});
-const extractTarGz = (archivePath, destinationDirectory) => new Promise((resolve, reject) => {
-  execFile("tar", ["-xzf", archivePath, "-C", destinationDirectory], (error) => {
-    if (error) {
-      reject(error);
-    } else {
-      resolve();
-    }
-  });
-});
-class RemoteCache {
-  #url;
-  #token;
-  #teamId;
-  #timeout;
-  #read;
-  #write;
-  #onUploadError;
-  constructor(options) {
-    this.#url = options.url.replace(/\/$/, "");
-    this.#token = options.token;
-    this.#teamId = options.teamId;
-    this.#timeout = options.timeout ?? 3e4;
-    this.#read = options.read ?? true;
-    this.#write = options.write ?? true;
-    this.#onUploadError = options.onUploadError;
-  }
-  /**
-   * Retrieves a cached artifact from the remote cache.
-   * Returns the local path to the extracted cache entry, or undefined if not found.
-   */
-  async retrieve(hash, localCacheDirectory) {
-    if (!this.#read) {
-      return false;
-    }
-    const entryDirectory = join(localCacheDirectory, hash);
-    const archivePath = join(localCacheDirectory, `.remote-${hash}.tar.gz`);
-    try {
-      const artifactUrl = this.#buildUrl(`/v8/artifacts/${hash}`);
-      const response = await fetch(artifactUrl, {
-        headers: this.#buildHeaders(),
-        method: "GET",
-        signal: AbortSignal.timeout(this.#timeout)
-      });
-      if (!response.ok) {
-        return false;
-      }
-      await mkdir(localCacheDirectory, { recursive: true });
-      const { body } = response;
-      if (!body) {
-        return false;
-      }
-      const fileStream = createWriteStream(archivePath);
-      await pipeline(body, fileStream);
-      await mkdir(entryDirectory, { recursive: true });
-      await extractTarGz(archivePath, entryDirectory);
-      await rm(archivePath, { force: true });
-      return true;
-    } catch {
-      await rm(archivePath, { force: true }).catch(() => {
-      });
-      await rm(entryDirectory, { force: true, recursive: true }).catch(() => {
-      });
-      return false;
-    }
-  }
-  /**
-   * Stores a cache entry in the remote cache.
-   */
-  async store(hash, localCacheDirectory) {
-    if (!this.#write) {
-      return false;
-    }
-    const entryDirectory = join(localCacheDirectory, hash);
-    const archivePath = join(localCacheDirectory, `.upload-${hash}.tar.gz`);
-    try {
-      await stat(join(entryDirectory, ".commit"));
-      await createTarGz(entryDirectory, archivePath);
-      const artifactUrl = this.#buildUrl(`/v8/artifacts/${hash}`);
-      const archiveContent = await readFile(archivePath);
-      const response = await fetch(artifactUrl, {
-        body: archiveContent,
-        headers: {
-          ...this.#buildHeaders(),
-          "Content-Length": String(archiveContent.length),
-          "Content-Type": "application/octet-stream"
-        },
-        method: "PUT",
-        signal: AbortSignal.timeout(this.#timeout)
-      });
-      await rm(archivePath, { force: true });
-      return response.ok;
-    } catch (error) {
-      await rm(archivePath, { force: true }).catch(() => {
-      });
-      this.#onUploadError?.(hash, error);
-      return false;
-    }
-  }
-  /**
-   * Checks if an artifact exists in the remote cache without downloading it.
-   */
-  async exists(hash) {
-    if (!this.#read) {
-      return false;
-    }
-    try {
-      const artifactUrl = this.#buildUrl(`/v8/artifacts/${hash}`);
-      const response = await fetch(artifactUrl, {
-        headers: this.#buildHeaders(),
-        method: "HEAD",
-        signal: AbortSignal.timeout(this.#timeout)
-      });
-      return response.ok;
-    } catch {
-      return false;
-    }
-  }
-  #buildUrl(path) {
-    const url = `${this.#url}${path}`;
-    if (this.#teamId) {
-      return `${url}?teamId=${encodeURIComponent(this.#teamId)}`;
-    }
-    return url;
-  }
-  #buildHeaders() {
-    const headers = {};
-    if (this.#token) {
-      headers["Authorization"] = `Bearer ${this.#token}`;
-    }
-    return headers;
-  }
-}
-
-export { RemoteCache };

package/dist/packem_shared/TaskOrchestrator-BvYs3ONw.js

@@ -1,342 +0,0 @@
-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

@@ -1,111 +0,0 @@
-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 };