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

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

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

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

package/dist/packem_shared/RemoteCache-BDqrnDEi.js

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