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

package/dist/packem_shared/extractPackageName-CbVNW-dr.js

@@ -0,0 +1,189 @@
+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
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { r as readPackageDeps, e as createXxh3Hasher } from './utils-zO0ZRgtf.js';
+import { join } from '@visulima/path';
+
+const extractPackageName = (path) => {
+  const match = /.*node_modules\/((?:@[^/]+\/)?[^/]+)/.exec(path);
+  if (!match?.[1]) {
+    return void 0;
+  }
+  const name = match[1];
+  if (name.startsWith(".")) {
+    return void 0;
+  }
+  return name;
+};
+const parseNpmLockfile = (content) => {
+  const versions = /* @__PURE__ */ new Map();
+  try {
+    const lockfile = JSON.parse(content);
+    if (lockfile.packages) {
+      for (const [path, entry] of Object.entries(lockfile.packages)) {
+        if (!path || !entry.version) {
+          continue;
+        }
+        const name = extractPackageName(path);
+        if (name && !versions.has(name)) {
+          versions.set(name, entry.version);
+        }
+      }
+    }
+    if (versions.size === 0 && lockfile.dependencies) {
+      for (const [name, entry] of Object.entries(lockfile.dependencies)) {
+        if (entry.version) {
+          versions.set(name, entry.version);
+        }
+      }
+    }
+  } catch {
+  }
+  return versions;
+};
+const parsePnpmLockfile = (content) => {
+  const versions = /* @__PURE__ */ new Map();
+  const depVersionRegex = /^\s{4,}(\S+):\n\s+specifier:.*\n\s+version:\s*'?([^'\n(]+)/gm;
+  let match;
+  while ((match = depVersionRegex.exec(content) ?? void 0) !== void 0) {
+    const name = match[1].replaceAll(/^['"]|['"]$/g, "");
+    let version = match[2].trim();
+    const parenIndex = version.indexOf("(");
+    if (parenIndex > 0) {
+      version = version.slice(0, parenIndex).trim();
+    }
+    if (!versions.has(name)) {
+      versions.set(name, version);
+    }
+  }
+  if (versions.size === 0) {
+    const packagesRegex = /^\s{2}[/'"]?(?:@([^/@']+)\/)?([^@']+)@(\d[^:'"\s]*)/gm;
+    while ((match = packagesRegex.exec(content) ?? void 0) !== void 0) {
+      const scope = match[1];
+      const name = scope ? `@${scope}/${match[2]}` : match[2];
+      const version = match[3];
+      if (!versions.has(name)) {
+        versions.set(name, version);
+      }
+    }
+  }
+  return versions;
+};
+const parseYarnLockfile = (content) => {
+  const versions = /* @__PURE__ */ new Map();
+  const entryRegex = /^["']?(?:@([^/@"']+)\/)?([^@"']+)@[^"'\n]+["']?:?[\t\v\f\r \u00A0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]*\n\s+version:?\s+"?([^"\n]+)"?/gm;
+  let match;
+  while ((match = entryRegex.exec(content) ?? void 0) !== void 0) {
+    const scope = match[1];
+    const name = scope ? `@${scope}/${match[2]}` : match[2];
+    const version = match[3].trim();
+    if (!versions.has(name)) {
+      versions.set(name, version);
+    }
+  }
+  return versions;
+};
+class LockfileHasher {
+  #workspaceRoot;
+  #lockfileCache;
+  #lockfileType;
+  constructor(workspaceRoot) {
+    this.#workspaceRoot = workspaceRoot;
+  }
+  /**
+   * 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
+   */
+  async hashForPackage(packageJsonPath) {
+    const fullPath = join(this.#workspaceRoot, packageJsonPath);
+    const deps = await readPackageDeps(fullPath);
+    if (!deps || deps.size === 0) {
+      return void 0;
+    }
+    const resolvedVersions = await this.#getResolvedVersions();
+    if (!resolvedVersions) {
+      return void 0;
+    }
+    const resolved = [];
+    for (const depName of deps) {
+      const version = resolvedVersions.get(depName);
+      if (version) {
+        resolved.push({ name: depName, version });
+      }
+    }
+    if (resolved.length === 0) {
+      return void 0;
+    }
+    resolved.sort((a, b) => a.name.localeCompare(b.name));
+    const hash = createXxh3Hasher();
+    for (const dependency of resolved) {
+      hash.update(`${dependency.name}@${dependency.version}`);
+    }
+    return {
+      dependencies: resolved,
+      hash: hash.digest()
+    };
+  }
+  /**
+   * Returns the type of lockfile detected, or undefined if none found.
+   */
+  get lockfileType() {
+    return this.#lockfileType;
+  }
+  /**
+   * Clears the cached lockfile data.
+   */
+  clearCache() {
+    this.#lockfileCache = void 0;
+    this.#lockfileType = void 0;
+  }
+  /**
+   * Parses the workspace lockfile and returns a map of package name → resolved version.
+   * Results are cached for subsequent calls.
+   */
+  async #getResolvedVersions() {
+    if (this.#lockfileCache !== void 0) {
+      return this.#lockfileCache.size > 0 ? this.#lockfileCache : void 0;
+    }
+    const parsers = [
+      { file: "package-lock.json", parser: parseNpmLockfile, type: "npm" },
+      { file: "pnpm-lock.yaml", parser: parsePnpmLockfile, type: "pnpm" },
+      { file: "yarn.lock", parser: parseYarnLockfile, type: "yarn" }
+    ];
+    for (const { file, parser, type } of parsers) {
+      try {
+        const content = await readFile(join(this.#workspaceRoot, file), "utf8");
+        const versions = parser(content);
+        this.#lockfileCache = versions;
+        this.#lockfileType = type;
+        return versions;
+      } catch {
+      }
+    }
+    this.#lockfileCache = /* @__PURE__ */ new Map();
+    return void 0;
+  }
+}
+
+export { LockfileHasher, extractPackageName, parseNpmLockfile, parsePnpmLockfile, parseYarnLockfile };

package/dist/packem_shared/filterAffectedTasks-I-18zPg6.js

@@ -0,0 +1,135 @@
+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 validateGitRef = (ref) => {
+  if (!/^[a-zA-Z0-9._\-/~^@{}]+$/.test(ref)) {
+    throw new Error(`Invalid git ref: "${ref}". Only alphanumeric characters, dots, dashes, underscores, slashes, tildes, carets, and @ are allowed.`);
+  }
+};
+const findProjectForFile = (filePath, projects) => {
+  let bestMatch;
+  let bestLength = 0;
+  for (const [name, config] of Object.entries(projects)) {
+    const { root } = config;
+    if ((filePath.startsWith(`${root}/`) || filePath === root) && root.length > bestLength) {
+      bestMatch = name;
+      bestLength = root.length;
+    }
+  }
+  return bestMatch;
+};
+const expandAffected = (affectedProjects, projectGraph) => {
+  const reverseDependencies = /* @__PURE__ */ new Map();
+  for (const [project, dependencies] of Object.entries(projectGraph.dependencies)) {
+    for (const dependency of dependencies) {
+      let set = reverseDependencies.get(dependency.target);
+      if (!set) {
+        set = /* @__PURE__ */ new Set();
+        reverseDependencies.set(dependency.target, set);
+      }
+      set.add(project);
+    }
+  }
+  const queue = [...affectedProjects];
+  while (queue.length > 0) {
+    const project = queue.shift();
+    if (project === void 0) {
+      continue;
+    }
+    const dependents = reverseDependencies.get(project);
+    if (dependents) {
+      for (const dependent of dependents) {
+        if (!affectedProjects.has(dependent)) {
+          affectedProjects.add(dependent);
+          queue.push(dependent);
+        }
+      }
+    }
+  }
+};
+const getMergeBase = (workspaceRoot, base, head) => new Promise((resolve, reject) => {
+  execFile("git", ["merge-base", base, head], { cwd: workspaceRoot }, (error, stdout) => {
+    if (error) {
+      reject(error);
+    } else {
+      resolve(stdout.trim());
+    }
+  });
+});
+const getChangedFiles = async (workspaceRoot, base, head) => {
+  validateGitRef(base);
+  validateGitRef(head);
+  try {
+    const mergeBase = await getMergeBase(workspaceRoot, base, head);
+    return await new Promise((resolve, reject) => {
+      execFile("git", ["diff", "--name-only", mergeBase, head], { cwd: workspaceRoot }, (error, stdout) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(stdout.trim().split("\n").filter(Boolean));
+        }
+      });
+    });
+  } catch {
+    return new Promise((resolve, reject) => {
+      execFile("git", ["diff", "--name-only", `${base}...${head}`], { cwd: workspaceRoot }, (error, stdout) => {
+        if (error) {
+          reject(error);
+        } else {
+          resolve(stdout.trim().split("\n").filter(Boolean));
+        }
+      });
+    });
+  }
+};
+const getAffectedProjects = async (options) => {
+  const { base = "main", head = "HEAD", projectGraph, projects, workspaceRoot } = options;
+  const changedFiles = await getChangedFiles(workspaceRoot, base, head);
+  const changedProjects = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    const project = findProjectForFile(file, projects);
+    if (project) {
+      changedProjects.add(project);
+    } else {
+      return {
+        affectedProjects: Object.keys(projects),
+        changedFiles,
+        changedProjects: Object.keys(projects)
+      };
+    }
+  }
+  const affectedProjects = new Set(changedProjects);
+  expandAffected(affectedProjects, projectGraph);
+  return {
+    affectedProjects: [...affectedProjects],
+    changedFiles,
+    changedProjects: [...changedProjects]
+  };
+};
+const filterAffectedTasks = (taskIds, affectedProjects) => taskIds.filter((taskId) => {
+  const parts = taskId.split(":");
+  const project = parts[0];
+  return affectedProjects.has(project);
+});
+
+export { filterAffectedTasks, getAffectedProjects, getChangedFiles };

package/dist/packem_shared/findCycle-DF4_BRdO.js

@@ -0,0 +1,212 @@
+const findCycle = (taskGraph) => {
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const parent = /* @__PURE__ */ new Map();
+  for (const taskId of Object.keys(taskGraph.tasks)) {
+    if (visited.has(taskId)) {
+      continue;
+    }
+    const stack = [taskId];
+    while (stack.length > 0) {
+      const current = stack[stack.length - 1];
+      if (!visited.has(current)) {
+        visited.add(current);
+        inStack.add(current);
+      }
+      const deps = taskGraph.dependencies[current] ?? [];
+      let foundUnvisited = false;
+      for (const dep of deps) {
+        if (inStack.has(dep)) {
+          const cycle = [dep];
+          let node = current;
+          while (node !== dep) {
+            cycle.push(node);
+            node = parent.get(node) ?? dep;
+          }
+          cycle.push(dep);
+          cycle.reverse();
+          return cycle;
+        }
+        if (!visited.has(dep)) {
+          parent.set(dep, current);
+          stack.push(dep);
+          foundUnvisited = true;
+          break;
+        }
+      }
+      if (!foundUnvisited) {
+        stack.pop();
+        inStack.delete(current);
+      }
+    }
+  }
+  return void 0;
+};
+const findCycles = (taskGraph) => {
+  const cycles = [];
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const stack = [];
+  const dfs = (taskId) => {
+    visited.add(taskId);
+    inStack.add(taskId);
+    stack.push(taskId);
+    const deps = taskGraph.dependencies[taskId] ?? [];
+    for (const dep of deps) {
+      if (inStack.has(dep)) {
+        const cycleStart = stack.indexOf(dep);
+        const cycle = [...stack.slice(cycleStart), dep];
+        cycles.push(cycle);
+      } else if (!visited.has(dep)) {
+        dfs(dep);
+      }
+    }
+    stack.pop();
+    inStack.delete(taskId);
+  };
+  for (const taskId of Object.keys(taskGraph.tasks)) {
+    if (!visited.has(taskId)) {
+      dfs(taskId);
+    }
+  }
+  return cycles;
+};
+const walkTaskGraph = (taskGraph, callback) => {
+  const dependencyCount = /* @__PURE__ */ new Map();
+  for (const taskId of Object.keys(taskGraph.tasks)) {
+    dependencyCount.set(taskId, (taskGraph.dependencies[taskId] ?? []).length);
+  }
+  const dependents = /* @__PURE__ */ new Map();
+  for (const [taskId, deps] of Object.entries(taskGraph.dependencies)) {
+    for (const dep of deps) {
+      let list = dependents.get(dep);
+      if (!list) {
+        list = [];
+        dependents.set(dep, list);
+      }
+      list.push(taskId);
+    }
+  }
+  const queue = [];
+  for (const [taskId, count] of dependencyCount) {
+    if (count === 0) {
+      queue.push(taskId);
+    }
+  }
+  while (queue.length > 0) {
+    const taskId = queue.shift();
+    callback(taskId);
+    const taskDependents = dependents.get(taskId) ?? [];
+    for (const dependent of taskDependents) {
+      const newCount = (dependencyCount.get(dependent) ?? 1) - 1;
+      dependencyCount.set(dependent, newCount);
+      if (newCount === 0) {
+        queue.push(dependent);
+      }
+    }
+  }
+};
+const reverseTaskGraph = (taskGraph) => {
+  const reversedDependencies = {};
+  for (const taskId of Object.keys(taskGraph.tasks)) {
+    reversedDependencies[taskId] = [];
+  }
+  for (const [taskId, deps] of Object.entries(taskGraph.dependencies)) {
+    for (const dep of deps) {
+      reversedDependencies[dep]?.push(taskId);
+    }
+  }
+  const roots = Object.keys(taskGraph.tasks).filter((taskId) => (reversedDependencies[taskId]?.length ?? 0) === 0);
+  return {
+    dependencies: reversedDependencies,
+    roots,
+    tasks: { ...taskGraph.tasks }
+  };
+};
+const getLeafTasks = (taskGraph) => Object.keys(taskGraph.tasks).filter((taskId) => (taskGraph.dependencies[taskId]?.length ?? 0) === 0);
+const makeAcyclic = (taskGraph) => {
+  const visited = /* @__PURE__ */ new Set();
+  const inStack = /* @__PURE__ */ new Set();
+  const edgesToRemove = [];
+  const dfs = (taskId) => {
+    visited.add(taskId);
+    inStack.add(taskId);
+    const deps = taskGraph.dependencies[taskId] ?? [];
+    for (const dep of deps) {
+      if (inStack.has(dep)) {
+        edgesToRemove.push({ from: taskId, to: dep });
+      } else if (!visited.has(dep)) {
+        dfs(dep);
+      }
+    }
+    inStack.delete(taskId);
+  };
+  for (const taskId of Object.keys(taskGraph.tasks)) {
+    if (!visited.has(taskId)) {
+      dfs(taskId);
+    }
+  }
+  const newDependencies = {};
+  for (const [taskId, deps] of Object.entries(taskGraph.dependencies)) {
+    newDependencies[taskId] = deps.filter((dep) => !edgesToRemove.some((edge) => edge.from === taskId && edge.to === dep));
+  }
+  const allDeps = /* @__PURE__ */ new Set();
+  for (const deps of Object.values(newDependencies)) {
+    for (const dep of deps) {
+      allDeps.add(dep);
+    }
+  }
+  const roots = Object.keys(taskGraph.tasks).filter((taskId) => !allDeps.has(taskId));
+  return {
+    dependencies: newDependencies,
+    roots,
+    tasks: { ...taskGraph.tasks }
+  };
+};
+const getDependentTasks = (taskGraph, taskId) => {
+  const reversed = reverseTaskGraph(taskGraph);
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [taskId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    if (current !== taskId) {
+      result.push(current);
+    }
+    const deps = reversed.dependencies[current] ?? [];
+    for (const dep of deps) {
+      if (!visited.has(dep)) {
+        queue.push(dep);
+      }
+    }
+  }
+  return result;
+};
+const getTransitiveDependencies = (taskGraph, taskId) => {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [taskId];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) {
+      continue;
+    }
+    visited.add(current);
+    if (current !== taskId) {
+      result.push(current);
+    }
+    const deps = taskGraph.dependencies[current] ?? [];
+    for (const dep of deps) {
+      if (!visited.has(dep)) {
+        queue.push(dep);
+      }
+    }
+  }
+  return result;
+};
+
+export { findCycle, findCycles, getDependentTasks, getLeafTasks, getTransitiveDependencies, makeAcyclic, reverseTaskGraph, walkTaskGraph };

package/dist/packem_shared/generateRunSummary-qn-_jKwt.js

@@ -0,0 +1,134 @@
+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 {
+  mkdir,
+  writeFile
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { join } from '@visulima/path';
+import { u as uniqueId } from './utils-zO0ZRgtf.js';
+
+const getCacheStatus = (result) => {
+  switch (result.status) {
+    case "local-cache":
+    case "local-cache-kept-existing": {
+      return "HIT";
+    }
+    case "remote-cache": {
+      return "REMOTE_HIT";
+    }
+    case "skipped": {
+      return "SKIPPED";
+    }
+    default: {
+      return "MISS";
+    }
+  }
+};
+const generateRunSummary = (results, taskGraph, startTime) => {
+  const endTime = Date.now();
+  const id = `${new Date(startTime).toISOString().replaceAll(/[:.]/g, "-")}_${uniqueId()}`;
+  const tasks = [];
+  let succeeded = 0;
+  let failed = 0;
+  let cached = 0;
+  let skipped = 0;
+  for (const [taskId, result] of results) {
+    const taskDeps = taskGraph.dependencies[taskId] ?? [];
+    const summary = {
+      cacheable: result.task.cache !== false,
+      cacheStatus: getCacheStatus(result),
+      dependencies: taskDeps,
+      duration: result.startTime && result.endTime ? result.endTime - result.startTime : void 0,
+      endTime: result.endTime ? new Date(result.endTime).toISOString() : void 0,
+      exitCode: result.code,
+      hash: result.task.hash,
+      hashDetails: result.task.hashDetails,
+      outputs: result.task.outputs,
+      startTime: result.startTime ? new Date(result.startTime).toISOString() : void 0,
+      target: {
+        configuration: result.task.target.configuration,
+        project: result.task.target.project,
+        target: result.task.target.target
+      },
+      taskId
+    };
+    tasks.push(summary);
+    switch (result.status) {
+      case "failure": {
+        failed += 1;
+        break;
+      }
+      case "local-cache":
+      // falls through
+      case "local-cache-kept-existing":
+      case "remote-cache": {
+        cached += 1;
+        break;
+      }
+      case "skipped": {
+        skipped += 1;
+        break;
+      }
+      case "success": {
+        succeeded += 1;
+        break;
+      }
+    }
+  }
+  const sortedTasks = tasks.toSorted((a, b) => {
+    if (!a.startTime || !b.startTime) {
+      return 0;
+    }
+    return a.startTime.localeCompare(b.startTime);
+  });
+  return {
+    duration: endTime - startTime,
+    endTime: new Date(endTime).toISOString(),
+    environment: {
+      arch: process.arch,
+      nodeVersion: process.version,
+      platform: process.platform
+    },
+    id,
+    startTime: new Date(startTime).toISOString(),
+    stats: {
+      cached,
+      failed,
+      skipped,
+      succeeded,
+      total: results.size
+    },
+    taskGraph: {
+      dependencies: taskGraph.dependencies,
+      roots: taskGraph.roots
+    },
+    tasks: sortedTasks
+  };
+};
+const writeRunSummary = async (summary, workspaceRoot) => {
+  const runsDirectory = join(workspaceRoot, ".task-runner", "runs");
+  await mkdir(runsDirectory, { recursive: true });
+  const filename = `${summary.id}.json`;
+  const filePath = join(runsDirectory, filename);
+  await writeFile(filePath, JSON.stringify(summary, void 0, 2));
+  return filePath;
+};
+
+export { generateRunSummary, writeRunSummary };

package/dist/packem_shared/isNativeAvailable-BWhnZ4ES.js

@@ -0,0 +1,19 @@
+import __cjs_mod__ from "node:module"; // -- packem CommonJS require shim --
+const require = __cjs_mod__.createRequire(import.meta.url);
+let nativeBindings;
+let loadAttempted = false;
+const loadNativeBindings = () => {
+  if (loadAttempted) {
+    return nativeBindings;
+  }
+  loadAttempted = true;
+  try {
+    nativeBindings = require("../binding.js");
+  } catch {
+    nativeBindings = void 0;
+  }
+  return nativeBindings;
+};
+const isNativeAvailable = () => loadNativeBindings() !== void 0;
+
+export { isNativeAvailable, loadNativeBindings };