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

package/dist/packem_shared/FileAccessTracker-CrtBAt5D.js

@@ -1,239 +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,
-  execFileSync
-} = __cjs_getBuiltinModule("node:child_process");
-const {
-  mkdir,
-  readFile,
-  rm
-} = __cjs_getBuiltinModule("node:fs/promises");
-const {
-  platform
-} = __cjs_getBuiltinModule("node:os");
-import { resolve, join } from '@visulima/path';
-import { u as uniqueId } from './utils-zO0ZRgtf.js';
-
-import __cjs_mod__ from "node:module"; // -- packem CommonJS require shim --
-const require = __cjs_mod__.createRequire(import.meta.url);
-let straceAvailable;
-const isStraceAvailable = () => {
-  if (straceAvailable === void 0) {
-    try {
-      execFileSync("strace", ["-V"], { stdio: "ignore" });
-      straceAvailable = true;
-    } catch {
-      straceAvailable = false;
-    }
-  }
-  return straceAvailable;
-};
-const STRACE_PATTERNS = [
-  { pattern: /openat\(AT_FDCWD,\s*"([^"]+)"/, type: "read" },
-  { pattern: /^(?:\d+\s+)?open\("([^"]+)"/, type: "read" },
-  { pattern: /(?:stat|lstat|newfstatat)\((?:AT_FDCWD,\s*)?"([^"]+)"/, type: "stat" },
-  { pattern: /access\("([^"]+)"/, type: "stat" }
-];
-class FileAccessTracker {
-  #workspaceRoot;
-  #excludePatterns;
-  /** Tracks active child processes for cleanup on abort */
-  #activeProcesses = /* @__PURE__ */ new Set();
-  constructor(workspaceRoot, excludePatterns) {
-    this.#workspaceRoot = resolve(workspaceRoot);
-    this.#excludePatterns = excludePatterns ?? [
-      /\/proc\//,
-      /\/sys\//,
-      /\/dev\//,
-      /\/tmp\//,
-      /\/etc\//,
-      /\.so(\.\d+)*$/,
-      /node_modules\/.package-lock\.json$/
-    ];
-  }
-  /**
-   * Returns true if file access tracking is supported on the current platform.
-   */
-  // eslint-disable-next-line class-methods-use-this
-  isSupported() {
-    return platform() === "linux" && isStraceAvailable();
-  }
-  /**
-   * Runs a command and tracks all file system accesses.
-   * On unsupported platforms, runs the command without tracking.
-   */
-  async track(command, options = {}) {
-    if (!this.isSupported()) {
-      return this.#runWithoutTracking(command, options);
-    }
-    return this.#runWithStrace(command, options);
-  }
-  /**
-   * Runs a command wrapped with strace to capture file accesses.
-   */
-  async #runWithStrace(command, options) {
-    const traceDirectory = join(this.#workspaceRoot, "node_modules", ".cache", "task-runner");
-    await mkdir(traceDirectory, { recursive: true });
-    const traceFile = join(traceDirectory, `strace-${uniqueId()}.log`);
-    const straceCommand = `strace -f -qq -e trace=open,openat,stat,lstat,newfstatat,access,getdents,getdents64 -o ${traceFile} -- ${command}`;
-    return new Promise((_resolve) => {
-      const child = exec(
-        straceCommand,
-        {
-          cwd: options.cwd ?? this.#workspaceRoot,
-          env: { ...process.env, ...options.env },
-          maxBuffer: 50 * 1024 * 1024
-          // 50MB
-        },
-        async (_error, stdout, stderr) => {
-          this.#activeProcesses.delete(child);
-          let accesses = [];
-          try {
-            const traceContent = await readFile(traceFile, "utf8");
-            accesses = this.#parseStraceOutput(traceContent, options.cwd ?? this.#workspaceRoot);
-          } catch {
-          }
-          await rm(traceFile, { force: true }).catch(() => {
-          });
-          _resolve({
-            accesses,
-            code: child.exitCode ?? 1,
-            output: stdout + stderr
-          });
-        }
-      );
-      this.#activeProcesses.add(child);
-    });
-  }
-  /**
-   * Parses strace output to extract file accesses.
-   */
-  #parseStraceOutput(traceContent, cwd) {
-    const accesses = [];
-    const seenPaths = /* @__PURE__ */ new Set();
-    for (const line of traceContent.split("\n")) {
-      const parsed = this.#parseStraceLine(line, cwd);
-      if (parsed && !seenPaths.has(parsed.path)) {
-        seenPaths.add(parsed.path);
-        accesses.push(parsed);
-      }
-    }
-    return accesses;
-  }
-  /**
-   * Parses a single strace output line.
-   * Each entry maps a regex to the file access type it represents.
-   */
-  #parseStraceLine(line, cwd) {
-    const isMissing = line.includes("ENOENT");
-    for (const { pattern, type } of STRACE_PATTERNS) {
-      const match = pattern.exec(line);
-      if (!match?.[1]) {
-        continue;
-      }
-      let path = match[1];
-      if (!path.startsWith("/")) {
-        path = resolve(cwd, path);
-      }
-      if (this.#shouldExclude(path) || !path.startsWith(this.#workspaceRoot)) {
-        return void 0;
-      }
-      return { path, type: isMissing ? "missing" : type };
-    }
-    return void 0;
-  }
-  /**
-   * Checks if a path should be excluded from tracking.
-   */
-  #shouldExclude(filePath) {
-    return this.#excludePatterns.some((pattern) => pattern.test(filePath));
-  }
-  /**
-   * Kills all active child processes. Called on abort/signal to prevent orphans.
-   */
-  killAll() {
-    for (const child of this.#activeProcesses) {
-      try {
-        child.kill("SIGTERM");
-      } catch {
-      }
-    }
-    this.#activeProcesses.clear();
-  }
-  /**
-   * Runs a command without file access tracking.
-   */
-  async #runWithoutTracking(command, options) {
-    return new Promise((_resolve) => {
-      const child = exec(
-        command,
-        {
-          cwd: options.cwd ?? this.#workspaceRoot,
-          env: { ...process.env, ...options.env },
-          maxBuffer: 50 * 1024 * 1024
-        },
-        (_error, stdout, stderr) => {
-          this.#activeProcesses.delete(child);
-          _resolve({
-            accesses: [],
-            code: child.exitCode ?? 1,
-            output: stdout + stderr
-          });
-        }
-      );
-      this.#activeProcesses.add(child);
-    });
-  }
-}
-const generatePreloadScript = (outputPath) => String.raw`
-import { createWriteStream } from "node:fs";
-
-const fs = require("node:fs");
-const fsp = require("node:fs/promises");
-const logStream = createWriteStream(${JSON.stringify(outputPath)}, { flags: "a" });
-const log = (type, path) => { logStream.write(JSON.stringify({ type, path }) + "\n"); };
-
-// Patch each fs method: save original, replace with logged wrapper
-const patch = (obj, method, type) => {
-    const orig = obj[method];
-    obj[method] = function(...args) {
-        log(type, args[0]?.toString());
-        return orig.apply(this, args);
-    };
-};
-
-// Sync
-patch(fs, "readFileSync", "read");
-patch(fs, "statSync", "stat");
-patch(fs, "readdirSync", "readdir");
-// Async (callback)
-patch(fs, "readFile", "read");
-patch(fs, "stat", "stat");
-patch(fs, "readdir", "readdir");
-// Async (promises)
-patch(fsp, "readFile", "read");
-patch(fsp, "stat", "stat");
-patch(fsp, "readdir", "readdir");
-
-process.on("beforeExit", () => { logStream.end(); });
-`;
-
-export { FileAccessTracker, generatePreloadScript };

package/dist/packem_shared/FingerprintManager-D6Y0erg-.js

@@ -1,227 +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 {
-  readdir,
-  stat
-} = __cjs_getBuiltinModule("node:fs/promises");
-import { resolve, relative } from '@visulima/path';
-import { b as hashStrings, s as sortObjectKeys, h as hashFile } from './utils-zO0ZRgtf.js';
-
-class FingerprintManager {
-  #workspaceRoot;
-  #fileHashCache = /* @__PURE__ */ new Map();
-  constructor(workspaceRoot) {
-    this.#workspaceRoot = resolve(workspaceRoot);
-  }
-  // eslint-disable-next-line sonarjs/cognitive-complexity
-  async createFingerprint(accesses, command, args, envVariables, envPatterns = [], untrackedEnvVariables = []) {
-    const fileHashes = {};
-    const missingPaths = /* @__PURE__ */ new Set();
-    const directoryListings = {};
-    for (const access of accesses) {
-      const relativePath = relative(this.#workspaceRoot, access.path);
-      switch (access.type) {
-        case "missing": {
-          missingPaths.add(relativePath);
-          break;
-        }
-        case "read":
-        case "stat": {
-          if (!fileHashes[relativePath]) {
-            const hash = await this.#hashFileWithCache(access.path);
-            if (hash) {
-              fileHashes[relativePath] = hash;
-            }
-          }
-          break;
-        }
-        case "readdir": {
-          if (!directoryListings[relativePath]) {
-            try {
-              const entries = await readdir(access.path);
-              directoryListings[relativePath] = entries.toSorted();
-            } catch {
-              directoryListings[relativePath] = [];
-            }
-          }
-          break;
-        }
-      }
-    }
-    const commandHash = hashStrings(`${command}:${JSON.stringify(sortObjectKeys(args))}`);
-    const envHashes = {};
-    const matchedEnvVariables = FingerprintManager.#resolveEnvPatterns(envPatterns, envVariables);
-    const untrackedSet = new Set(untrackedEnvVariables);
-    for (const [key, value] of Object.entries(matchedEnvVariables)) {
-      if (untrackedSet.has(key)) {
-        continue;
-      }
-      envHashes[key] = hashStrings(`${key}=${value ?? ""}`);
-    }
-    const missingFiles = [...missingPaths].toSorted();
-    return { commandHash, directoryListings, envHashes, fileHashes, missingFiles };
-  }
-  /**
-   * Validates a stored fingerprint against the current state.
-   * Returns null if valid (cache hit), or an array of reasons (cache miss).
-   *
-   * Does NOT use the file hash cache — validation must see current disk state.
-   */
-  async validate(fingerprint) {
-    const reasons = [];
-    const fileCheckPromises = Object.entries(fingerprint.fileHashes).map(async ([relativePath, previousHash]) => {
-      const absolutePath = resolve(this.#workspaceRoot, relativePath);
-      const currentHash = await hashFile(absolutePath);
-      if (!currentHash) {
-        return { detail: relativePath, previousHash, type: "file-deleted" };
-      }
-      if (currentHash !== previousHash) {
-        return { currentHash, detail: relativePath, previousHash, type: "file-changed" };
-      }
-      return void 0;
-    });
-    const missingCheckPromises = fingerprint.missingFiles.map(async (relativePath) => {
-      const absolutePath = resolve(this.#workspaceRoot, relativePath);
-      try {
-        await stat(absolutePath);
-        return { detail: relativePath, type: "file-created" };
-      } catch {
-        return void 0;
-      }
-    });
-    const directoryCheckPromises = Object.entries(fingerprint.directoryListings).map(async ([relativePath, previousEntries]) => {
-      const absolutePath = resolve(this.#workspaceRoot, relativePath);
-      try {
-        const readdirResult = await readdir(absolutePath);
-        const currentEntries = readdirResult.toSorted();
-        if (JSON.stringify(previousEntries) !== JSON.stringify(currentEntries)) {
-          return {
-            currentHash: JSON.stringify(currentEntries),
-            detail: relativePath,
-            previousHash: JSON.stringify(previousEntries),
-            type: "directory-changed"
-          };
-        }
-      } catch {
-        return { detail: relativePath, type: "directory-changed" };
-      }
-      return void 0;
-    });
-    const [fileResults, missingResults, directoryResults] = await Promise.all([
-      Promise.all(fileCheckPromises),
-      Promise.all(missingCheckPromises),
-      Promise.all(directoryCheckPromises)
-    ]);
-    for (const r of [...fileResults, ...missingResults, ...directoryResults]) {
-      if (r) {
-        reasons.push(r);
-      }
-    }
-    for (const [envName, previousHash] of Object.entries(fingerprint.envHashes)) {
-      const currentHash = hashStrings(`${envName}=${process.env[envName] ?? ""}`);
-      if (currentHash !== previousHash) {
-        reasons.push({
-          currentHash,
-          detail: envName,
-          previousHash,
-          type: "env-changed"
-        });
-      }
-    }
-    return reasons.length > 0 ? reasons : void 0;
-  }
-  // eslint-disable-next-line class-methods-use-this
-  validateCommand(fingerprint, command, args) {
-    const currentHash = hashStrings(`${command}:${JSON.stringify(sortObjectKeys(args))}`);
-    if (currentHash !== fingerprint.commandHash) {
-      return {
-        currentHash,
-        detail: "command arguments",
-        previousHash: fingerprint.commandHash,
-        type: "args-changed"
-      };
-    }
-    return void 0;
-  }
-  // eslint-disable-next-line class-methods-use-this
-  formatMissReasons(reasons) {
-    const lines = ["Cache miss reasons:"];
-    for (const reason of reasons) {
-      switch (reason.type) {
-        case "args-changed": {
-          lines.push(`  - Command arguments changed`);
-          break;
-        }
-        case "directory-changed": {
-          lines.push(`  - Directory contents changed: ${reason.detail}`);
-          break;
-        }
-        case "env-changed": {
-          lines.push(`  - Environment variable changed: ${reason.detail}`);
-          break;
-        }
-        case "file-changed": {
-          lines.push(`  - File modified: ${reason.detail}`);
-          break;
-        }
-        case "file-created": {
-          lines.push(`  - File created (was missing): ${reason.detail}`);
-          break;
-        }
-        case "file-deleted": {
-          lines.push(`  - File deleted: ${reason.detail}`);
-          break;
-        }
-        case "no-fingerprint": {
-          lines.push(`  - No previous fingerprint found (first run)`);
-          break;
-        }
-      }
-    }
-    return lines.join("\n");
-  }
-  static #resolveEnvPatterns(patterns, envVariables) {
-    const result = {};
-    for (const pattern of patterns) {
-      if (pattern.includes("*")) {
-        const prefix = pattern.replace("*", "");
-        for (const [key, value] of Object.entries(envVariables)) {
-          if (key.startsWith(prefix)) {
-            result[key] = value;
-          }
-        }
-      } else {
-        result[pattern] = envVariables[pattern];
-      }
-    }
-    return result;
-  }
-  async #hashFileWithCache(filePath) {
-    const cached = this.#fileHashCache.get(filePath);
-    if (cached !== void 0) {
-      return cached;
-    }
-    const hash = await hashFile(filePath) ?? void 0;
-    this.#fileHashCache.set(filePath, hash);
-    return hash;
-  }
-}
-
-export { FingerprintManager };

package/dist/packem_shared/IncrementalFileHasher-Ds3J6dgb.js

@@ -1,151 +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 {
-  readFile,
-  mkdir,
-  writeFile,
-  stat
-} = __cjs_getBuiltinModule("node:fs/promises");
-import { c as collectFiles, x as xxh3Hash } from './utils-zO0ZRgtf.js';
-import { join, dirname, relative } from '@visulima/path';
-
-const DEFAULT_IGNORED_DIRS = /* @__PURE__ */ new Set([".cache", ".git", ".task-runner-cache", "coverage", "dist", "node_modules"]);
-class IncrementalFileHasher {
-  #workspaceRoot;
-  #ignoredDirs;
-  #snapshotPath;
-  #snapshot = /* @__PURE__ */ new Map();
-  #loaded = false;
-  constructor(options) {
-    this.#workspaceRoot = options.workspaceRoot;
-    this.#ignoredDirs = options.ignoredDirs ?? DEFAULT_IGNORED_DIRS;
-    this.#snapshotPath = options.snapshotPath ?? join(options.workspaceRoot, "node_modules", ".cache", "task-runner", "file-snapshot.json");
-  }
-  /**
-   * Loads the snapshot from disk if available.
-   * Called automatically on first use.
-   */
-  async load() {
-    if (this.#loaded) {
-      return;
-    }
-    this.#loaded = true;
-    if (!this.#snapshotPath) {
-      return;
-    }
-    try {
-      const content = await readFile(this.#snapshotPath, "utf8");
-      const data = JSON.parse(content);
-      for (const [path, snap] of Object.entries(data)) {
-        this.#snapshot.set(path, snap);
-      }
-    } catch {
-    }
-  }
-  /**
-   * Persists the current snapshot to disk for cross-run reuse.
-   */
-  async save() {
-    if (!this.#snapshotPath) {
-      return;
-    }
-    const directory = dirname(this.#snapshotPath);
-    await mkdir(directory, { recursive: true });
-    const data = {};
-    for (const [path, snap] of this.#snapshot) {
-      data[path] = snap;
-    }
-    await writeFile(this.#snapshotPath, JSON.stringify(data));
-  }
-  /**
-   * Incrementally hashes all files in a directory.
-   *
-   * Only files whose mtime or size changed since the last snapshot
-   * are re-read and re-hashed. Unchanged files reuse the cached hash.
-   *
-   * Returns a map of relative paths → hashes.
-   */
-  async hashDirectory(directoryPath) {
-    await this.load();
-    const result = {};
-    const filePaths = await collectFiles(directoryPath, this.#ignoredDirs);
-    const BATCH_SIZE = 64;
-    const batches = [];
-    for (let i = 0; i < filePaths.length; i += BATCH_SIZE) {
-      batches.push(filePaths.slice(i, i + BATCH_SIZE));
-    }
-    for (const batch of batches) {
-      const batchResults = await Promise.all(
-        batch.map(async (filePath) => {
-          const hash = await this.#hashFileIncremental(filePath);
-          const relativePath = relative(this.#workspaceRoot, filePath);
-          return { hash, relativePath };
-        })
-      );
-      for (const { hash, relativePath } of batchResults) {
-        if (hash) {
-          result[relativePath] = hash;
-        }
-      }
-    }
-    return result;
-  }
-  /**
-   * Hashes a single file incrementally.
-   * Returns the cached hash if mtime + size haven't changed.
-   */
-  async #hashFileIncremental(filePath) {
-    try {
-      const fileStat = await stat(filePath);
-      if (!fileStat.isFile()) {
-        return void 0;
-      }
-      const cached = this.#snapshot.get(filePath);
-      if (cached && cached.mtimeMs === fileStat.mtimeMs && cached.size === fileStat.size) {
-        return cached.hash;
-      }
-      const content = await readFile(filePath);
-      const hash = xxh3Hash(content);
-      this.#snapshot.set(filePath, {
-        hash,
-        mtimeMs: fileStat.mtimeMs,
-        size: fileStat.size
-      });
-      return hash;
-    } catch {
-      this.#snapshot.delete(filePath);
-      return void 0;
-    }
-  }
-  /**
-   * Returns how many files are in the snapshot (for diagnostics).
-   */
-  get snapshotSize() {
-    return this.#snapshot.size;
-  }
-  /**
-   * Clears the in-memory snapshot.
-   */
-  clear() {
-    this.#snapshot.clear();
-  }
-}
-
-export { IncrementalFileHasher };