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

package/dist/packem_shared/createTaskGraph-CcsFaSrz.js

@@ -1,164 +0,0 @@
-const getTaskId = (target) => {
-  const parts = [target.project, target.target];
-  if (target.configuration) {
-    parts.push(target.configuration);
-  }
-  return parts.join(":");
-};
-const parseTaskId = (taskId) => {
-  const parts = taskId.split(":");
-  if (parts.length < 2) {
-    throw new Error(`Invalid task ID: ${taskId}`);
-  }
-  return {
-    configuration: parts[2],
-    project: parts[0],
-    target: parts[1]
-  };
-};
-const getTaskOutputs = (projectName, targetName, workspace, targetDefaults) => {
-  const project = workspace.projects[projectName];
-  const targetConfig = project?.targets?.[targetName];
-  const defaultConfig = targetDefaults?.[targetName];
-  const outputs = targetConfig?.outputs ?? defaultConfig?.outputs ?? [];
-  return outputs.map((output) => output.replace("{projectRoot}", project?.root ?? "").replace("{projectName}", projectName));
-};
-const getSameProjectTask = (projectName, targetName, overrides, workspace, targetDefaults) => {
-  const project = workspace.projects[projectName];
-  if (!project) {
-    return [];
-  }
-  const hasTarget = project.targets?.[targetName] !== void 0 || targetDefaults?.[targetName] !== void 0;
-  if (!hasTarget) {
-    return [];
-  }
-  const target = {
-    project: projectName,
-    target: targetName
-  };
-  return [
-    {
-      cache: project.targets?.[targetName]?.cache ?? targetDefaults?.[targetName]?.cache,
-      id: getTaskId(target),
-      outputs: getTaskOutputs(projectName, targetName, workspace, targetDefaults),
-      overrides,
-      parallelism: project.targets?.[targetName]?.parallelism ?? targetDefaults?.[targetName]?.parallelism,
-      projectRoot: project.root,
-      target
-    }
-  ];
-};
-const getDependencyProjectTasks = (projectName, targetName, overrides, workspace, projectGraph, targetDefaults) => {
-  const tasks = [];
-  const deps = projectGraph.dependencies[projectName] ?? [];
-  for (const dep of deps) {
-    const depProject = workspace.projects[dep.target];
-    if (!depProject) {
-      continue;
-    }
-    const hasTarget = depProject.targets?.[targetName] !== void 0 || targetDefaults?.[targetName] !== void 0;
-    if (hasTarget) {
-      const target = {
-        project: dep.target,
-        target: targetName
-      };
-      tasks.push({
-        cache: depProject.targets?.[targetName]?.cache ?? targetDefaults?.[targetName]?.cache,
-        id: getTaskId(target),
-        outputs: getTaskOutputs(dep.target, targetName, workspace, targetDefaults),
-        overrides,
-        parallelism: depProject.targets?.[targetName]?.parallelism ?? targetDefaults?.[targetName]?.parallelism,
-        projectRoot: depProject.root,
-        target
-      });
-    }
-  }
-  return tasks;
-};
-const resolveStringDependency = (task, dep, workspace, projectGraph, targetDefaults) => {
-  if (dep.startsWith("^")) {
-    const targetName = dep.slice(1);
-    return getDependencyProjectTasks(task.target.project, targetName, task.overrides, workspace, projectGraph, targetDefaults);
-  }
-  return getSameProjectTask(task.target.project, dep, task.overrides, workspace, targetDefaults);
-};
-const resolveConfigDependency = (task, dep, workspace, projectGraph, targetDefaults) => {
-  const tasks = [];
-  if (dep.dependencies) {
-    tasks.push(
-      ...getDependencyProjectTasks(
-        task.target.project,
-        dep.target,
-        dep.params === "forward" ? task.overrides : {},
-        workspace,
-        projectGraph,
-        targetDefaults
-      )
-    );
-  } else if (dep.projects) {
-    const projects = Array.isArray(dep.projects) ? dep.projects : [dep.projects];
-    for (const projectName of projects) {
-      tasks.push(...getSameProjectTask(projectName, dep.target, dep.params === "forward" ? task.overrides : {}, workspace, targetDefaults));
-    }
-  } else {
-    tasks.push(...getSameProjectTask(task.target.project, dep.target, dep.params === "forward" ? task.overrides : {}, workspace, targetDefaults));
-  }
-  return tasks;
-};
-const resolveDependency = (task, dep, workspace, projectGraph, targetDefaults) => {
-  if (typeof dep === "string") {
-    return resolveStringDependency(task, dep, workspace, projectGraph, targetDefaults);
-  }
-  return resolveConfigDependency(task, dep, workspace, projectGraph, targetDefaults);
-};
-const resolveTaskDependencies = (task, options) => {
-  const { projectGraph, targetDefaults, workspace } = options;
-  const project = workspace.projects[task.target.project];
-  if (!project) {
-    return [];
-  }
-  const targetConfig = project.targets?.[task.target.target];
-  const defaultConfig = targetDefaults?.[task.target.target];
-  const dependsOn = targetConfig?.dependsOn ?? defaultConfig?.dependsOn ?? [];
-  const depTasks = [];
-  for (const dep of dependsOn) {
-    const resolved = resolveDependency(task, dep, workspace, projectGraph, targetDefaults);
-    depTasks.push(...resolved);
-  }
-  return depTasks;
-};
-const createTaskGraph = (initialTasks, options) => {
-  const tasks = {};
-  const dependencies = {};
-  const visited = /* @__PURE__ */ new Set();
-  const queue = [...initialTasks];
-  while (queue.length > 0) {
-    const task = queue.shift();
-    if (!task) {
-      break;
-    }
-    if (visited.has(task.id)) {
-      continue;
-    }
-    visited.add(task.id);
-    tasks[task.id] = task;
-    dependencies[task.id] = [];
-    const deps = resolveTaskDependencies(task, options);
-    for (const depTask of deps) {
-      dependencies[task.id]?.push(depTask.id);
-      if (!visited.has(depTask.id)) {
-        queue.push(depTask);
-      }
-    }
-  }
-  const allDeps = /* @__PURE__ */ new Set();
-  for (const deps of Object.values(dependencies)) {
-    for (const dep of deps) {
-      allDeps.add(dep);
-    }
-  }
-  const roots = Object.keys(tasks).filter((taskId) => !allDeps.has(taskId));
-  return { dependencies, roots, tasks };
-};
-
-export { createTaskGraph, getTaskId, parseTaskId };

package/dist/packem_shared/defaultTaskRunner-CrW4v5Ye.js

@@ -1,79 +0,0 @@
-import { Cache } from './Cache-IYpTYVUC.js';
-import { inferFrameworkEnvPatterns } from './detectFrameworks-CeFzKE6J.js';
-import { EmptyLifeCycle } from './CompositeLifeCycle-7AtYw1dv.js';
-import { RemoteCache } from './RemoteCache-BDqrnDEi.js';
-import { InProcessTaskHasher } from './computeTaskHash-BoCnnvIJ.js';
-import { TaskOrchestrator } from './TaskOrchestrator-BvYs3ONw.js';
-import { TaskScheduler } from './TaskScheduler-CJilHDta.js';
-
-const resolveParallel = (parallel) => {
-  if (typeof parallel === "number") {
-    return Math.max(1, parallel);
-  }
-  if (parallel === false) {
-    return 1;
-  }
-  return 3;
-};
-const defaultTaskRunner = async (_tasks, options, context) => {
-  const { lifeCycle = new EmptyLifeCycle(), projectGraph, taskExecutor, taskGraph, workspaceRoot } = context;
-  const cache = new Cache({
-    cacheDirectory: options.cacheDirectory,
-    maxCacheAge: options.maxCacheAge,
-    maxCacheSize: options.maxCacheSize,
-    workspaceRoot
-  });
-  cache.removeOldEntries().catch(() => {
-  });
-  const projects = {};
-  for (const [name, node] of Object.entries(projectGraph.nodes)) {
-    projects[name] = node.data;
-  }
-  const taskHasher = new InProcessTaskHasher({
-    envVars: options.envVars,
-    frameworkInference: options.frameworkInference,
-    globalEnv: options.globalEnv,
-    globalInputs: options.globalInputs,
-    namedInputs: options.namedInputs,
-    projects,
-    smartLockfileHashing: options.smartLockfileHashing,
-    targetDefaults: options.targetDefaults,
-    workspaceRoot
-  });
-  const maxParallel = resolveParallel(options.parallel);
-  const scheduler = new TaskScheduler(taskGraph, projectGraph, maxParallel);
-  const resolveCommand = (task) => {
-    const project = projectGraph.nodes[task.target.project];
-    const targetConfig = project?.data.targets?.[task.target.target];
-    const defaultConfig = options.targetDefaults?.[task.target.target];
-    return targetConfig?.command ?? defaultConfig?.command;
-  };
-  const remoteCache = options.remoteCache ? new RemoteCache(options.remoteCache) : void 0;
-  let fingerprintEnvPatterns = options.fingerprintEnvPatterns ?? [];
-  if (options.frameworkInference && options.autoFingerprint) {
-    const inferredPatterns = await inferFrameworkEnvPatterns(workspaceRoot, projects);
-    fingerprintEnvPatterns = [.../* @__PURE__ */ new Set([...fingerprintEnvPatterns, ...inferredPatterns])];
-  }
-  const orchestrator = new TaskOrchestrator({
-    autoFingerprint: options.autoFingerprint,
-    cache,
-    cacheDiagnostics: options.cacheDiagnostics,
-    captureOutput: true,
-    dryRun: options.dryRun,
-    fingerprintEnvPatterns,
-    lifeCycle,
-    remoteCache,
-    resolveCommand: options.autoFingerprint ? resolveCommand : void 0,
-    scheduler,
-    skipCache: options.skipNxCache,
-    summarize: options.summarize,
-    taskExecutor,
-    taskGraph,
-    taskHasher,
-    untrackedEnvVars: options.untrackedEnvVars,
-    workspaceRoot
-  });
-  return orchestrator.run();
-};
-
-export { defaultTaskRunner };

package/dist/packem_shared/detectFrameworks-CeFzKE6J.js

@@ -1,101 +0,0 @@
-import { join } from '@visulima/path';
-import { r as readPackageDeps } from './utils-zO0ZRgtf.js';
-
-const FRAMEWORK_DEFINITIONS = [
-  {
-    envPrefixes: ["NEXT_PUBLIC_"],
-    name: "Next.js",
-    packages: ["next"]
-  },
-  {
-    envPrefixes: ["VITE_"],
-    name: "Vite",
-    packages: ["vite"]
-  },
-  {
-    envPrefixes: ["REACT_APP_"],
-    name: "Create React App",
-    packages: ["react-scripts"]
-  },
-  {
-    envPrefixes: ["GATSBY_"],
-    name: "Gatsby",
-    packages: ["gatsby"]
-  },
-  {
-    envPrefixes: ["NUXT_PUBLIC_"],
-    name: "Nuxt",
-    packages: ["nuxt", "nuxt3"]
-  },
-  {
-    envPrefixes: ["EXPO_PUBLIC_"],
-    name: "Expo",
-    packages: ["expo"]
-  },
-  {
-    envPrefixes: ["REMIX_PUBLIC_"],
-    name: "Remix",
-    packages: ["@remix-run/react", "@remix-run/node"]
-  },
-  {
-    envPrefixes: ["PUBLIC_"],
-    name: "Astro",
-    packages: ["astro"]
-  },
-  {
-    envPrefixes: ["PUBLIC_"],
-    name: "SvelteKit",
-    packages: ["@sveltejs/kit"]
-  },
-  {
-    envPrefixes: ["VITE_"],
-    name: "Solid Start",
-    packages: ["@solidjs/start", "solid-start"]
-  }
-];
-const detectFrameworks = async (packageJsonPath) => {
-  const allDeps = await readPackageDeps(packageJsonPath, { optional: false, peer: false });
-  if (!allDeps) {
-    return [];
-  }
-  const detected = [];
-  for (const framework of FRAMEWORK_DEFINITIONS) {
-    if (framework.packages.some((pkg) => allDeps.has(pkg))) {
-      detected.push({
-        envPrefixes: framework.envPrefixes,
-        name: framework.name
-      });
-    }
-  }
-  return detected;
-};
-const inferFrameworkEnvPatterns = async (workspaceRoot, projects) => {
-  const allPrefixes = /* @__PURE__ */ new Set();
-  const detectionPromises = Object.values(projects).map(async (project) => {
-    const packageJsonPath = join(workspaceRoot, project.root, "package.json");
-    const frameworks = await detectFrameworks(packageJsonPath);
-    for (const fw of frameworks) {
-      for (const prefix of fw.envPrefixes) {
-        allPrefixes.add(prefix);
-      }
-    }
-  });
-  await Promise.all(detectionPromises);
-  return [...allPrefixes].toSorted().map((prefix) => `${prefix}*`);
-};
-const getFrameworkEnvVariables = async (packageJsonPath, env = process.env) => {
-  const frameworks = await detectFrameworks(packageJsonPath);
-  const result = {};
-  for (const framework of frameworks) {
-    for (const prefix of framework.envPrefixes) {
-      for (const [key, value] of Object.entries(env)) {
-        if (key.startsWith(prefix) && value !== void 0) {
-          result[key] = value;
-        }
-      }
-    }
-  }
-  return result;
-};
-
-export { detectFrameworks, getFrameworkEnvVariables, inferFrameworkEnvPatterns };

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

@@ -1,189 +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
-} = __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

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