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

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

@@ -1,164 +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 {
-  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

@@ -1,22 +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);
-};
-
-
-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';

package/dist/packem_shared/computeTaskHash-BoCnnvIJ.js

@@ -1,356 +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 {
-  readFile
-} = __cjs_getBuiltinModule("node:fs/promises");
-import { b as hashStrings, s as sortObjectKeys, c as collectFiles, x as xxh3Hash, e as createXxh3Hasher } from './utils-zO0ZRgtf.js';
-import { join, resolve, relative } from '@visulima/path';
-import { getFrameworkEnvVariables } from './detectFrameworks-CeFzKE6J.js';
-import { LockfileHasher } from './extractPackageName-CbVNW-dr.js';
-import { loadNativeBindings } from './isNativeAvailable-BWhnZ4ES.js';
-
-const DEFAULT_GLOBAL_INPUTS = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "tsconfig.base.json", "tsconfig.json", ".env"];
-const IGNORED_DIRS = /* @__PURE__ */ new Set([".git", "coverage", "dist", "node_modules"]);
-const LOCKFILE_NAMES = /* @__PURE__ */ new Set(["package-lock.json", "pnpm-lock.yaml", "yarn.lock"]);
-let cachedNative;
-const getNativeBindings = () => {
-  if (cachedNative === void 0) {
-    cachedNative = loadNativeBindings();
-  }
-  return cachedNative;
-};
-const hashSortedEntries = (hash, record, prefix) => {
-  for (const key of Object.keys(record).toSorted()) {
-    {
-      hash.update(`${key}\0`);
-    }
-    hash.update(record[key]);
-  }
-};
-const executeRuntimeCommand = (runtime) => {
-  if (runtime === "node -v" || runtime === "node --version") {
-    return Promise.resolve(process.version);
-  }
-  const parts = runtime.split(/\s+/);
-  const command = parts[0];
-  const args = parts.slice(1);
-  return new Promise((resolve2) => {
-    execFile(command, args, { timeout: 1e4 }, (error, stdout) => {
-      if (error) {
-        resolve2(`__runtime_error__:${runtime}`);
-      } else {
-        resolve2(stdout.trim());
-      }
-    });
-  });
-};
-const runtimeCache = /* @__PURE__ */ new Map();
-const hashRuntimeValue = async (runtime) => {
-  let output = runtimeCache.get(runtime);
-  if (output === void 0) {
-    output = await executeRuntimeCommand(runtime);
-    runtimeCache.set(runtime, output);
-  }
-  return hashStrings(runtime, output);
-};
-const isFileSetInput = (input) => "fileset" in input;
-const isRuntimeInput = (input) => "runtime" in input;
-const isEnvironmentInput = (input) => "env" in input;
-const isExternalDependencyInput = (input) => "externalDependencies" in input;
-class InProcessTaskHasher {
-  #workspaceRoot;
-  #projects;
-  #namedInputs;
-  #targetDefaults;
-  #envVars;
-  #globalInputs;
-  #globalEnv;
-  #fileHashCache = /* @__PURE__ */ new Map();
-  #native;
-  #smartLockfileHashing;
-  #lockfileHasher;
-  #frameworkInference;
-  #globalHash = void 0;
-  constructor(options) {
-    this.#workspaceRoot = options.workspaceRoot;
-    this.#projects = options.projects;
-    this.#namedInputs = options.namedInputs ?? {};
-    this.#targetDefaults = options.targetDefaults ?? {};
-    this.#envVars = options.envVars ?? [];
-    this.#globalInputs = options.globalInputs ?? DEFAULT_GLOBAL_INPUTS;
-    this.#globalEnv = options.globalEnv ?? [];
-    this.#native = getNativeBindings();
-    this.#smartLockfileHashing = options.smartLockfileHashing ?? false;
-    this.#lockfileHasher = this.#smartLockfileHashing ? new LockfileHasher(options.workspaceRoot) : void 0;
-    this.#frameworkInference = options.frameworkInference ?? false;
-  }
-  // eslint-disable-next-line sonarjs/cognitive-complexity
-  async hashTask(task) {
-    const commandHash = this.#hashCommand(task);
-    const nodes = {};
-    const implicitDeps = {};
-    const runtime = {};
-    const globalHash = await this.#computeGlobalHash();
-    if (globalHash) {
-      implicitDeps["__global__"] = globalHash;
-    }
-    const inputs = this.#resolveInputs(task);
-    const negationPatterns = this.#collectNegationPatterns(inputs, task.target.project);
-    for (const input of inputs) {
-      if (isFileSetInput(input)) {
-        const fileHashes = await this.#hashFileSet(task, input.fileset, negationPatterns);
-        for (const [filePath, hash] of Object.entries(fileHashes)) {
-          nodes[filePath] = hash;
-        }
-      } else if (isRuntimeInput(input)) {
-        runtime[input.runtime] = await hashRuntimeValue(input.runtime);
-      } else if (isEnvironmentInput(input)) {
-        runtime[`env:${input.env}`] = hashStrings(input.env, process.env[input.env] ?? "");
-      } else if (isExternalDependencyInput(input)) {
-        const depHashes = await Promise.all(input.externalDependencies.map(async (dep) => [dep, await this.#hashExternalDependency(dep)]));
-        for (const [dep, hash] of depHashes) {
-          implicitDeps[dep] = hash;
-        }
-      }
-    }
-    for (const envVariable of this.#envVars) {
-      runtime[`env:${envVariable}`] = hashStrings(envVariable, process.env[envVariable] ?? "");
-    }
-    const project = this.#projects[task.target.project];
-    if (project) {
-      if (this.#lockfileHasher) {
-        const lockfileHash = await this.#lockfileHasher.hashForPackage(join(project.root, "package.json"));
-        if (lockfileHash) {
-          implicitDeps["__lockfile__"] = lockfileHash.hash;
-        }
-      }
-      if (this.#frameworkInference) {
-        const packageJsonPath = resolve(this.#workspaceRoot, project.root, "package.json");
-        const frameworkEnvVariables = await getFrameworkEnvVariables(packageJsonPath);
-        for (const envName of Object.keys(frameworkEnvVariables)) {
-          runtime[`framework-env:${envName}`] = hashStrings(envName, process.env[envName] ?? "");
-        }
-      }
-    }
-    return {
-      command: commandHash,
-      implicitDeps: Object.keys(implicitDeps).length > 0 ? implicitDeps : void 0,
-      nodes,
-      runtime: Object.keys(runtime).length > 0 ? runtime : void 0
-    };
-  }
-  /**
-   * Hashes the command identity for a task using xxh3-128.
-   * Uses native Rust implementation when available, otherwise pure TS xxh3-ts.
-   * Both produce identical xxh3-128 output.
-   */
-  #hashCommand(task) {
-    const overridesJson = JSON.stringify(sortObjectKeys(task.overrides));
-    if (this.#native) {
-      return this.#native.hashCommand(task.target.project, task.target.target, task.target.configuration ?? void 0, overridesJson);
-    }
-    const hash = createXxh3Hasher();
-    hash.update(task.target.project);
-    hash.update(task.target.target);
-    if (task.target.configuration) {
-      hash.update(task.target.configuration);
-    }
-    hash.update(overridesJson);
-    return hash.digest();
-  }
-  #resolveInputs(task) {
-    const project = this.#projects[task.target.project];
-    const targetConfig = project?.targets?.[task.target.target];
-    const defaultConfig = this.#targetDefaults[task.target.target];
-    const rawInputs = targetConfig?.inputs ?? defaultConfig?.inputs;
-    if (!rawInputs) {
-      return [{ fileset: "{projectRoot}/**/*" }];
-    }
-    return this.#expandInputs(rawInputs, task.target.project);
-  }
-  #expandInputs(inputs, projectName) {
-    const result = [];
-    const seen = /* @__PURE__ */ new Set();
-    for (const input of inputs) {
-      if (typeof input === "string") {
-        if (input.startsWith("{") || input.startsWith("!{")) {
-          result.push({ fileset: input });
-        } else if (input.startsWith("^")) {
-          continue;
-        } else if (this.#namedInputs[input] && !seen.has(input)) {
-          seen.add(input);
-          result.push(...this.#expandInputs(this.#namedInputs[input], projectName));
-        } else {
-          result.push({ fileset: input });
-        }
-      } else {
-        result.push(input);
-      }
-    }
-    return result;
-  }
-  #collectNegationPatterns(inputs, projectName) {
-    const project = this.#projects[projectName];
-    const projectRoot = project?.root ?? "";
-    const patterns = [];
-    for (const input of inputs) {
-      if (!isFileSetInput(input)) {
-        continue;
-      }
-      const resolved = input.fileset.replace("{projectRoot}", projectRoot).replace("{workspaceRoot}", ".");
-      if (resolved.startsWith("!")) {
-        patterns.push(
-          resolved.slice(1).replace(/\/\*\*\/\*$/, "").replace(/\/\*$/, "")
-        );
-      }
-    }
-    return patterns;
-  }
-  /**
-   * Hashes all files matching a fileset pattern.
-   * Uses native Rust parallel hashing (via rayon) when available.
-   */
-  async #hashFileSet(task, pattern, negationPatterns = []) {
-    const project = this.#projects[task.target.project];
-    const projectRoot = project?.root ?? "";
-    const resolvedPattern = pattern.replace("{projectRoot}", projectRoot).replace("{workspaceRoot}", ".");
-    if (resolvedPattern.startsWith("!")) {
-      return {};
-    }
-    const absoluteBase = resolve(this.#workspaceRoot, resolvedPattern.replace(/\/\*\*\/\*$/, "").replace(/\/\*$/, ""));
-    const absoluteNegations = negationPatterns.map((p) => resolve(this.#workspaceRoot, p));
-    const result = {};
-    const isExcluded = (filePath) => absoluteNegations.some((neg) => filePath.startsWith(`${neg}/`) || filePath === neg);
-    try {
-      if (this.#native) {
-        const fileHashes = this.#native.hashFilesInDirectory(absoluteBase, this.#workspaceRoot);
-        for (const { hash, path } of fileHashes) {
-          const absPath = resolve(this.#workspaceRoot, path);
-          if (!isExcluded(absPath)) {
-            result[path] = hash;
-            this.#fileHashCache.set(absPath, hash);
-          }
-        }
-        return result;
-      }
-      const files = await collectFiles(absoluteBase, IGNORED_DIRS);
-      const hashPromises = files.map(async (filePath) => {
-        if (isExcluded(filePath)) {
-          return;
-        }
-        const hash = await this.#hashFile(filePath);
-        if (hash) {
-          result[relative(this.#workspaceRoot, filePath)] = hash;
-        }
-      });
-      await Promise.all(hashPromises);
-    } catch {
-    }
-    return result;
-  }
-  async #hashFile(filePath) {
-    const cached = this.#fileHashCache.get(filePath);
-    if (cached) {
-      return cached;
-    }
-    try {
-      const content = await readFile(filePath);
-      const hash = xxh3Hash(content);
-      this.#fileHashCache.set(filePath, hash);
-      return hash;
-    } catch {
-      return void 0;
-    }
-  }
-  async #hashExternalDependency(depName) {
-    try {
-      const packageJsonPath = join(this.#workspaceRoot, "node_modules", depName, "package.json");
-      const packageJsonContent = await readFile(packageJsonPath, "utf8");
-      const packageJson = JSON.parse(packageJsonContent);
-      return hashStrings(depName, packageJson.version ?? "unknown");
-    } catch {
-      return hashStrings(depName, "not-installed");
-    }
-  }
-  /**
-   * Computes a combined hash of all global inputs and global env vars.
-   * Cached after first computation.
-   */
-  async #computeGlobalHash() {
-    if (this.#globalHash !== void 0) {
-      return this.#globalHash;
-    }
-    const hash = createXxh3Hasher();
-    let hasContent = false;
-    const globalFileHashes = await Promise.all(
-      this.#globalInputs.filter((input) => !(this.#smartLockfileHashing && LOCKFILE_NAMES.has(input))).map(async (globalInput) => {
-        const fileHash = await this.#hashFile(join(this.#workspaceRoot, globalInput));
-        return fileHash ? { hash: fileHash, name: globalInput } : void 0;
-      })
-    );
-    for (const entry of globalFileHashes) {
-      if (entry) {
-        hash.update(entry.name);
-        hash.update(entry.hash);
-        hasContent = true;
-      }
-    }
-    for (const envName of this.#globalEnv) {
-      hash.update(`globalEnv:${envName}=${process.env[envName] ?? ""}`);
-      hasContent = true;
-    }
-    this.#globalHash = hasContent ? hash.digest() : "";
-    return this.#globalHash || void 0;
-  }
-  clearCache() {
-    this.#fileHashCache.clear();
-    this.#globalHash = void 0;
-    this.#lockfileHasher?.clearCache();
-  }
-}
-const computeTaskHash = (hashDetails) => {
-  const native = getNativeBindings();
-  if (native) {
-    const nodes = Object.keys(hashDetails.nodes).toSorted().map((key) => [key, hashDetails.nodes[key]]);
-    const implicitDeps = hashDetails.implicitDeps ? Object.keys(hashDetails.implicitDeps).toSorted().map((key) => [key, hashDetails.implicitDeps[key]]) : void 0;
-    const runtime = hashDetails.runtime ? Object.keys(hashDetails.runtime).toSorted().map((key) => [key, hashDetails.runtime[key]]) : void 0;
-    return native.computeTaskHash({
-      command: hashDetails.command,
-      implicit_deps: implicitDeps,
-      nodes,
-      runtime
-    });
-  }
-  const hash = createXxh3Hasher();
-  hash.update(hashDetails.command);
-  hashSortedEntries(hash, hashDetails.nodes);
-  if (hashDetails.implicitDeps) {
-    hashSortedEntries(hash, hashDetails.implicitDeps);
-  }
-  if (hashDetails.runtime) {
-    hashSortedEntries(hash, hashDetails.runtime);
-  }
-  return hash.digest();
-};
-
-export { InProcessTaskHasher, computeTaskHash };