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

package/dist/life-cycle.d.ts

@@ -1,36 +0,0 @@
-import type { LifeCycleInterface, Task, TaskResult, TaskStatus } from "./types.d.ts";
-/**
- * Combines multiple lifecycle handlers into one.
- * Each event is forwarded to all registered handlers.
- */
-declare class CompositeLifeCycle implements LifeCycleInterface {
-    #private;
-    constructor(lifeCycles: LifeCycleInterface[]);
-    startCommand(): void;
-    endCommand(): void;
-    scheduleTask(task: Task): void;
-    startTasks(tasks: Task[]): void;
-    endTasks(taskResults: TaskResult[]): void;
-    printTaskTerminalOutput(task: Task, status: TaskStatus, terminalOutput: string): void;
-    printCacheMiss(task: Task, reasons: string): void;
-}
-/**
- * A lifecycle handler that logs task progress to the console.
- */
-declare class ConsoleLifeCycle implements LifeCycleInterface {
-    #private;
-    constructor(verbose?: boolean);
-    startCommand(): void;
-    endCommand(): void;
-    scheduleTask(task: Task): void;
-    startTasks(tasks: Task[]): void;
-    endTasks(taskResults: TaskResult[]): void;
-    printTaskTerminalOutput(_task: Task, _status: TaskStatus, terminalOutput: string): void;
-    printCacheMiss(task: Task, reasons: string): void;
-}
-/**
- * A no-op lifecycle handler. Useful as a default.
- */
-declare class EmptyLifeCycle implements LifeCycleInterface {
-}
-export { CompositeLifeCycle, ConsoleLifeCycle, EmptyLifeCycle };

package/dist/lockfile-hasher.d.ts

@@ -1,73 +0,0 @@
-/**
- * Resolved dependency entry from a lockfile.
- */
-interface ResolvedDependency {
-    /** The package name */
-    name: string;
-    /** The resolved version */
-    version: string;
-}
-/**
- * Result of parsing a lockfile for a specific package.
- */
-interface PackageLockfileHash {
-    /** The resolved dependencies that were included in the hash */
-    dependencies: ResolvedDependency[];
-    /** Hash of the resolved dependencies relevant to this package */
-    hash: string;
-}
-/**
- * Extracts a package name from a node_modules path.
- * E.g., "node_modules/@scope/name" -> "@scope/name",
- * "node_modules/name" -> "name",
- * "node_modules/.package-lock.json" -> undefined.
- */
-declare const extractPackageName: (path: string) => string | undefined;
-/**
- * Parses package-lock.json (npm v2/v3 format) to extract resolved versions.
- * The v2/v3 format uses a flat "packages" map with paths like "node_modules/pkg-name".
- */
-declare const parseNpmLockfile: (content: string) => Map<string, string>;
-/**
- * Parses pnpm-lock.yaml to extract resolved versions.
- * Uses a lightweight regex-based parser to avoid a YAML dependency.
- */
-declare const parsePnpmLockfile: (content: string) => Map<string, string>;
-/**
- * Parses yarn.lock to extract resolved versions.
- * Works with both Yarn Classic (v1) and Berry (v2+) formats.
- */
-declare const parseYarnLockfile: (content: string) => Map<string, string>;
-/**
- * Smart lockfile hasher that only hashes the resolved versions
- * of a package's actual dependencies, not the entire lockfile.
- *
- * This matches Turborepo's smart lockfile hashing behavior:
- * changing the lockfile only busts cache for affected packages.
- *
- * Supports:
- * - package-lock.json (npm v2/v3)
- * - pnpm-lock.yaml (pnpm)
- * - yarn.lock (Yarn Classic + Berry)
- */
-declare class LockfileHasher {
-    #private;
-    constructor(workspaceRoot: string);
-    /**
-     * Computes a hash based only on the resolved dependency versions
-     * relevant to a specific package.
-     * @param packageJsonPath Path to the package.json (relative to workspace root)
-     * @returns Hash of the relevant lockfile entries, or undefined if no lockfile found
-     */
-    hashForPackage(packageJsonPath: string): Promise<PackageLockfileHash | undefined>;
-    /**
-     * Returns the type of lockfile detected, or undefined if none found.
-     */
-    get lockfileType(): "npm" | "pnpm" | "yarn" | undefined;
-    /**
-     * Clears the cached lockfile data.
-     */
-    clearCache(): void;
-}
-export type { PackageLockfileHash, ResolvedDependency };
-export { extractPackageName, LockfileHasher, parseNpmLockfile, parsePnpmLockfile, parseYarnLockfile };

package/dist/native-binding.d.ts

@@ -1,64 +0,0 @@
-/**
- * Optional native bindings for performance-critical operations.
- *
- * The native addon (Rust via napi-rs) provides:
- * - Parallel file hashing using rayon + xxHash xxh3-128
- * - Optimized task hash computation
- * - Fast graph operations (cycle detection, topological sort)
- *
- * Falls back to pure TypeScript implementations when the native
- * addon is not available (not compiled, wrong platform, etc.).
- *
- * Build with: pnpm build:native
- * The napi v3 CLI outputs the .node file to the package root.
- */
-interface NativeFileHash {
-    hash: string;
-    path: string;
-}
-interface NativeTaskHashDetails {
-    command: string;
-    implicit_deps?: string[][];
-    nodes: string[][];
-    runtime?: string[][];
-}
-interface NativeTaskGraph {
-    edges: string[][];
-    task_ids: string[];
-}
-interface NativeCycleResult {
-    cycle: string[];
-    has_cycle: boolean;
-}
-interface NativeBindings {
-    collectFiles: (directory: string) => string[];
-    computeTaskHash: (details: NativeTaskHashDetails) => string;
-    findAllCycles: (graph: NativeTaskGraph) => string[][];
-    findBackEdges: (graph: NativeTaskGraph) => string[][];
-    findCycle: (graph: NativeTaskGraph) => NativeCycleResult;
-    getDependentTasks: (graph: NativeTaskGraph, taskId: string) => string[];
-    getTransitiveDeps: (graph: NativeTaskGraph, taskId: string) => string[];
-    hashCommand: (project: string, target: string, configuration: string | undefined, overridesJson: string) => string;
-    hashEnvVar: (name: string, value: string) => string;
-    hashFile: (filePath: string) => string;
-    hashFilesBatch: (filePaths: string[], workspaceRoot: string) => NativeFileHash[];
-    hashFilesInDirectory: (directory: string, workspaceRoot: string) => NativeFileHash[];
-    hashString: (input: string) => string;
-    hashStrings: (inputs: string[]) => string;
-    topologicalSort: (graph: NativeTaskGraph) => string[];
-}
-/**
- * Attempts to load the native addon. Returns undefined if unavailable.
- * The result is cached after the first attempt.
- *
- * napi v3 outputs the .node file to the package root as
- * `task-runner-native.<platform>.node`. The napi-generated binding.js
- * handles platform detection automatically.
- */
-declare const loadNativeBindings: () => NativeBindings | undefined;
-/**
- * Returns true if the native addon is loaded and available.
- */
-declare const isNativeAvailable: () => boolean;
-export type { NativeBindings, NativeCycleResult, NativeFileHash, NativeTaskGraph, NativeTaskHashDetails };
-export { isNativeAvailable, loadNativeBindings };

package/dist/packem_shared/Cache-IYpTYVUC.js

@@ -1,298 +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,
-  rename,
-  stat,
-  rm,
-  cp,
-  readdir
-} = __cjs_getBuiltinModule("node:fs/promises");
-import { join, resolve, dirname } from '@visulima/path';
-import { formatBytes, parseBytes } from '@visulima/humanizer';
-import { u as uniqueId } from './utils-zO0ZRgtf.js';
-
-const DEFAULT_MAX_CACHE_AGE = 7 * 24 * 60 * 60 * 1e3;
-const removeEntry = async (entryPath) => {
-  try {
-    await rm(entryPath, { force: true, recursive: true });
-  } catch {
-  }
-};
-const getDirectorySize = async (directoryPath) => {
-  let totalSize = 0;
-  try {
-    const entries = await readdir(directoryPath, { withFileTypes: true });
-    for (const entry of entries) {
-      const fullPath = join(directoryPath, entry.name);
-      if (entry.isDirectory()) {
-        totalSize += await getDirectorySize(fullPath);
-      } else if (entry.isFile()) {
-        const fileStat = await stat(fullPath);
-        totalSize += fileStat.size;
-      }
-    }
-  } catch {
-  }
-  return totalSize;
-};
-const parseCacheSize = (sizeString) => {
-  const result = parseBytes(sizeString.trim());
-  if (Number.isNaN(result)) {
-    throw new Error(`Invalid cache size format: "${sizeString}". Expected format like "500MB" or "1GB".`);
-  }
-  return result;
-};
-const formatCacheSize = (bytes) => formatBytes(bytes, { decimals: 1, space: false });
-class Cache {
-  #workspaceRoot;
-  #cacheDirectory;
-  #maxCacheAge;
-  #maxCacheSize;
-  /** Serializes concurrent setTaskIndex writes to prevent lost updates */
-  #indexWriteQueue = Promise.resolve();
-  constructor(options) {
-    this.#workspaceRoot = options.workspaceRoot;
-    this.#cacheDirectory = options.cacheDirectory ?? join(options.workspaceRoot, ".task-runner-cache");
-    this.#maxCacheAge = options.maxCacheAge ?? DEFAULT_MAX_CACHE_AGE;
-    this.#maxCacheSize = options.maxCacheSize ? parseCacheSize(options.maxCacheSize) : void 0;
-  }
-  /**
-   * Gets the cache directory path.
-   */
-  get cacheDirectory() {
-    return this.#cacheDirectory;
-  }
-  /**
-   * Retrieves a cached result for the given task hash.
-   * Returns undefined if no valid cache entry exists.
-   */
-  async get(hash) {
-    const cacheEntryDirectory = join(this.#cacheDirectory, hash);
-    try {
-      await readFile(join(cacheEntryDirectory, ".commit"));
-      const codeString = await readFile(join(cacheEntryDirectory, "code"), "utf8");
-      const code = Number.parseInt(codeString.trim(), 10);
-      if (Number.isNaN(code)) {
-        return void 0;
-      }
-      let terminalOutput = "";
-      try {
-        terminalOutput = await readFile(join(cacheEntryDirectory, "terminalOutput"), "utf8");
-      } catch {
-      }
-      let fingerprint;
-      try {
-        const fingerprintContent = await readFile(join(cacheEntryDirectory, "fingerprint.json"), "utf8");
-        fingerprint = JSON.parse(fingerprintContent);
-      } catch {
-      }
-      return { code, fingerprint, hash, terminalOutput };
-    } catch {
-      return void 0;
-    }
-  }
-  /**
-   * Stores a task result in the cache.
-   *
-   * Uses atomic write: builds the entry in a temporary directory,
-   * then renames into place to avoid partial reads by concurrent processes.
-   */
-  async put(hash, terminalOutput, outputs, code, fingerprint) {
-    const cacheEntryDirectory = join(this.#cacheDirectory, hash);
-    const temporaryDirectory = join(this.#cacheDirectory, `.tmp-${hash}-${uniqueId()}`);
-    try {
-      await mkdir(temporaryDirectory, { recursive: true });
-      const writes = [
-        writeFile(join(temporaryDirectory, "code"), String(code)),
-        writeFile(join(temporaryDirectory, "terminalOutput"), terminalOutput),
-        this.#archiveOutputs(temporaryDirectory, outputs)
-      ];
-      if (fingerprint) {
-        writes.push(writeFile(join(temporaryDirectory, "fingerprint.json"), JSON.stringify(fingerprint)));
-      }
-      await Promise.all(writes);
-      await writeFile(join(temporaryDirectory, ".commit"), "");
-      await removeEntry(cacheEntryDirectory);
-      await rename(temporaryDirectory, cacheEntryDirectory);
-    } catch {
-      await removeEntry(temporaryDirectory);
-    }
-  }
-  /**
-   * Restores cached outputs to their original locations.
-   */
-  async restoreOutputs(hash, outputs) {
-    const cacheEntryDirectory = join(this.#cacheDirectory, hash);
-    const outputsDirectory = join(cacheEntryDirectory, "outputs");
-    try {
-      await stat(outputsDirectory);
-    } catch {
-      return true;
-    }
-    try {
-      await Promise.all(
-        outputs.map(async (output) => {
-          const absoluteOutput = resolve(this.#workspaceRoot, output);
-          const cachedOutput = join(outputsDirectory, output);
-          try {
-            await stat(cachedOutput);
-          } catch {
-            return;
-          }
-          const parentDirectory = dirname(absoluteOutput);
-          await mkdir(parentDirectory, { recursive: true });
-          await rm(absoluteOutput, { force: true, recursive: true });
-          await cp(cachedOutput, absoluteOutput, { recursive: true });
-        })
-      );
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  /**
-   * Retrieves the most recent cached result for a task by its ID.
-   * Used in auto-fingerprint mode where the hash is derived from
-   * tracked file accesses rather than computed upfront.
-   */
-  async getByTaskId(taskId) {
-    const indexFile = join(this.#cacheDirectory, ".task-index.json");
-    try {
-      const indexContent = await readFile(indexFile, "utf8");
-      const index = JSON.parse(indexContent);
-      const hash = index[taskId];
-      if (!hash) {
-        return void 0;
-      }
-      return this.get(hash);
-    } catch {
-      return void 0;
-    }
-  }
-  /**
-   * Stores the mapping from task ID to cache hash.
-   * Uses a write queue to serialize concurrent writes and prevent lost updates.
-   * Each write is atomic (temp file + rename).
-   */
-  async setTaskIndex(taskId, hash) {
-    this.#indexWriteQueue = this.#indexWriteQueue.then(() => this.#writeTaskIndex(taskId, hash)).catch(() => {
-    });
-    return this.#indexWriteQueue;
-  }
-  async #writeTaskIndex(taskId, hash) {
-    const indexFile = join(this.#cacheDirectory, ".task-index.json");
-    const temporaryFile = join(this.#cacheDirectory, `.task-index-${uniqueId()}.tmp`);
-    let index = {};
-    try {
-      const indexContent = await readFile(indexFile, "utf8");
-      index = JSON.parse(indexContent);
-    } catch {
-    }
-    index[taskId] = hash;
-    await mkdir(this.#cacheDirectory, { recursive: true });
-    await writeFile(temporaryFile, JSON.stringify(index));
-    try {
-      await rename(temporaryFile, indexFile);
-    } catch {
-      await writeFile(indexFile, JSON.stringify(index));
-      await rm(temporaryFile, { force: true });
-    }
-  }
-  /**
-   * Removes old cache entries that exceed the maximum age,
-   * and enforces the maximum cache size by evicting oldest entries.
-   */
-  // eslint-disable-next-line sonarjs/cognitive-complexity
-  async removeOldEntries() {
-    try {
-      const entries = await readdir(this.#cacheDirectory);
-      const now = Date.now();
-      const entryInfos = [];
-      for (const entry of entries) {
-        if (entry.startsWith(".")) {
-          continue;
-        }
-        const entryPath = join(this.#cacheDirectory, entry);
-        try {
-          const entryStat = await stat(entryPath);
-          if (now - entryStat.mtimeMs > this.#maxCacheAge) {
-            await removeEntry(entryPath);
-          } else {
-            const size = await getDirectorySize(entryPath);
-            entryInfos.push({
-              mtimeMs: entryStat.mtimeMs,
-              name: entry,
-              path: entryPath,
-              size
-            });
-          }
-        } catch {
-        }
-      }
-      if (this.#maxCacheSize !== void 0) {
-        const sortedEntries = entryInfos.toSorted((a, b) => a.mtimeMs - b.mtimeMs);
-        let totalSize = 0;
-        for (const info of sortedEntries) {
-          totalSize += info.size;
-        }
-        for (const info of sortedEntries) {
-          if (totalSize <= this.#maxCacheSize) {
-            break;
-          }
-          await removeEntry(info.path);
-          totalSize -= info.size;
-        }
-      }
-    } catch {
-    }
-  }
-  /**
-   * Clears the entire cache.
-   */
-  async clear() {
-    try {
-      await rm(this.#cacheDirectory, { force: true, recursive: true });
-    } catch {
-    }
-  }
-  /**
-   * Archives task output files into the cache.
-   */
-  async #archiveOutputs(cacheEntryDirectory, outputs) {
-    const outputsDirectory = join(cacheEntryDirectory, "outputs");
-    await mkdir(outputsDirectory, { recursive: true });
-    for (const output of outputs) {
-      const absoluteOutput = resolve(this.#workspaceRoot, output);
-      const cachedOutput = join(outputsDirectory, output);
-      try {
-        await stat(absoluteOutput);
-        const cachedOutputParent = join(cachedOutput, "..");
-        await mkdir(cachedOutputParent, { recursive: true });
-        await cp(absoluteOutput, cachedOutput, { recursive: true });
-      } catch {
-      }
-    }
-  }
-}
-
-export { Cache, formatCacheSize, parseCacheSize };

package/dist/packem_shared/CompositeLifeCycle-7AtYw1dv.js

@@ -1,112 +0,0 @@
-const getStatusIcon = (status) => {
-  switch (status) {
-    case "failure": {
-      return "[failure]";
-    }
-    case "local-cache":
-    case "local-cache-kept-existing":
-    case "remote-cache": {
-      return "[cache]";
-    }
-    case "skipped": {
-      return "[skipped]";
-    }
-    case "success": {
-      return "[success]";
-    }
-    default: {
-      return "[unknown]";
-    }
-  }
-};
-class CompositeLifeCycle {
-  #lifeCycles;
-  constructor(lifeCycles) {
-    this.#lifeCycles = lifeCycles;
-  }
-  startCommand() {
-    for (const lc of this.#lifeCycles) {
-      lc.startCommand?.();
-    }
-  }
-  endCommand() {
-    for (const lc of this.#lifeCycles) {
-      lc.endCommand?.();
-    }
-  }
-  scheduleTask(task) {
-    for (const lc of this.#lifeCycles) {
-      lc.scheduleTask?.(task);
-    }
-  }
-  startTasks(tasks) {
-    for (const lc of this.#lifeCycles) {
-      lc.startTasks?.(tasks);
-    }
-  }
-  endTasks(taskResults) {
-    for (const lc of this.#lifeCycles) {
-      lc.endTasks?.(taskResults);
-    }
-  }
-  printTaskTerminalOutput(task, status, terminalOutput) {
-    for (const lc of this.#lifeCycles) {
-      lc.printTaskTerminalOutput?.(task, status, terminalOutput);
-    }
-  }
-  printCacheMiss(task, reasons) {
-    for (const lc of this.#lifeCycles) {
-      lc.printCacheMiss?.(task, reasons);
-    }
-  }
-}
-class ConsoleLifeCycle {
-  #verbose;
-  constructor(verbose = false) {
-    this.#verbose = verbose;
-  }
-  startCommand() {
-    if (this.#verbose) {
-      console.log("[task-runner] Starting command execution");
-    }
-  }
-  endCommand() {
-    if (this.#verbose) {
-      console.log("[task-runner] Command execution complete");
-    }
-  }
-  scheduleTask(task) {
-    if (this.#verbose) {
-      console.log(`[task-runner] Scheduled: ${task.id}`);
-    }
-  }
-  // eslint-disable-next-line class-methods-use-this
-  startTasks(tasks) {
-    for (const task of tasks) {
-      console.log(`> ${task.id}`);
-    }
-  }
-  // eslint-disable-next-line class-methods-use-this
-  endTasks(taskResults) {
-    for (const result of taskResults) {
-      const duration = result.startTime && result.endTime ? ` (${result.endTime - result.startTime}ms)` : "";
-      const statusIcon = getStatusIcon(result.status);
-      console.log(`${statusIcon} ${result.task.id}${duration}`);
-    }
-  }
-  // eslint-disable-next-line class-methods-use-this
-  printTaskTerminalOutput(_task, _status, terminalOutput) {
-    if (terminalOutput.trim()) {
-      console.log(terminalOutput);
-    }
-  }
-  printCacheMiss(task, reasons) {
-    if (this.#verbose) {
-      console.log(`[task-runner] ${task.id}: ${reasons}`);
-    }
-  }
-}
-class EmptyLifeCycle {
-}
-
-export { CompositeLifeCycle, ConsoleLifeCycle, EmptyLifeCycle };