@lage-run/cli 0.11.3 → 0.12.0

package/CHANGELOG.json

@@ -2,7 +2,67 @@
   "name": "@lage-run/cli",
   "entries": [
     {
-      "date": "Wed, 29 Mar 2023 20:02:22 GMT",
+      "date": "Thu, 30 Mar 2023 23:46:39 GMT",
+      "tag": "@lage-run/cli_v0.12.0",
+      "version": "0.12.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "41360ccbd7433afe537342c4c815b1e02bc9c9b8",
+            "comment": "moved caching to happen inside workers"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler to v0.11.0",
+            "commit": "41360ccbd7433afe537342c4c815b1e02bc9c9b8"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 29 Mar 2023 22:41:49 GMT",
+      "tag": "@lage-run/cli_v0.11.4",
+      "version": "0.11.4",
+      "comments": {
+        "patch": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "ec458f83e5adb784019efaa06f902ec75f85990c",
+            "comment": "moving config to its own package"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/config to v0.1.1",
+            "commit": "ec458f83e5adb784019efaa06f902ec75f85990c"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler to v0.10.5",
+            "commit": "ec458f83e5adb784019efaa06f902ec75f85990c"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/scheduler-types to v0.3.5",
+            "commit": "ec458f83e5adb784019efaa06f902ec75f85990c"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/reporters to v1.0.7",
+            "commit": "ec458f83e5adb784019efaa06f902ec75f85990c"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Wed, 29 Mar 2023 20:02:40 GMT",
       "tag": "@lage-run/cli_v0.11.3",
       "version": "0.11.3",
       "comments": {

package/CHANGELOG.md

@@ -1,12 +1,33 @@
 # Change Log - @lage-run/cli
 
-This log was last generated on Wed, 29 Mar 2023 20:02:22 GMT and should not be manually modified.
+This log was last generated on Thu, 30 Mar 2023 23:46:39 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.12.0
+
+Thu, 30 Mar 2023 23:46:39 GMT
+
+### Minor changes
+
+- moved caching to happen inside workers (kchau@microsoft.com)
+- Bump @lage-run/scheduler to v0.11.0
+
+## 0.11.4
+
+Wed, 29 Mar 2023 22:41:49 GMT
+
+### Patches
+
+- moving config to its own package (kchau@microsoft.com)
+- Bump @lage-run/config to v0.1.1
+- Bump @lage-run/scheduler to v0.10.5
+- Bump @lage-run/scheduler-types to v0.3.5
+- Bump @lage-run/reporters to v1.0.7
+
 ## 0.11.3
 
-Wed, 29 Mar 2023 20:02:22 GMT
+Wed, 29 Mar 2023 20:02:40 GMT
 
 ### Patches
 

package/lib/commands/affected/action.js

@@ -8,7 +8,7 @@ Object.defineProperty(exports, "affectedAction", {
 });
 const _logger = /*#__PURE__*/ _interopRequireDefault(require("@lage-run/logger"));
 const _workspaceTools = require("workspace-tools");
-const _getConfigJs = require("../../config/getConfig.js");
+const _config = require("@lage-run/config");
 const _getFilteredPackagesJs = require("../../filter/getFilteredPackages.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
@@ -18,7 +18,7 @@ function _interopRequireDefault(obj) {
 async function affectedAction(options) {
     const { dependencies , dependents , since , scope , ignore , outputFormat  } = options;
     const cwd = process.cwd();
-    const config = await (0, _getConfigJs.getConfig)(cwd);
+    const config = await (0, _config.getConfig)(cwd);
     const logger = (0, _logger.default)();
     const root = (0, _workspaceTools.getWorkspaceRoot)(cwd);
     const packageInfos = (0, _workspaceTools.getPackageInfos)(root);

package/lib/commands/cache/action.js

@@ -7,7 +7,7 @@ Object.defineProperty(exports, "cacheAction", {
     get: ()=>cacheAction
 });
 const _clearCacheJs = require("./clearCache.js");
-const _getConfigJs = require("../../config/getConfig.js");
+const _config = require("@lage-run/config");
 const _pruneCacheJs = require("./pruneCache.js");
 const _logger = /*#__PURE__*/ _interopRequireDefault(require("@lage-run/logger"));
 function _interopRequireDefault(obj) {
@@ -17,7 +17,7 @@ function _interopRequireDefault(obj) {
 }
 async function cacheAction(options, command) {
     const cwd = process.cwd();
-    const config = await (0, _getConfigJs.getConfig)(cwd);
+    const config = await (0, _config.getConfig)(cwd);
     const logger = (0, _logger.default)();
     if (options.clear) {
         return await (0, _clearCacheJs.clearCache)({

package/lib/commands/cache/clearCache.js

@@ -6,15 +6,14 @@ Object.defineProperty(exports, "clearCache", {
     enumerable: true,
     get: ()=>clearCache
 });
-const _getConfigJs = require("../../config/getConfig.js");
+const _config = require("@lage-run/config");
 const _workspaceTools = require("workspace-tools");
-const _getConcurrencyJs = require("../../config/getConcurrency.js");
 const _cache = require("@lage-run/cache");
 async function clearCache(options) {
     const { logger , cwd  } = options;
-    const config = await (0, _getConfigJs.getConfig)(cwd);
+    const config = await (0, _config.getConfig)(cwd);
     const workspaceRoot = (0, _workspaceTools.getWorkspaceRoot)(cwd);
-    const concurrency = (0, _getConcurrencyJs.getConcurrency)(options.concurrency, config.concurrency);
+    const concurrency = (0, _config.getConcurrency)(options.concurrency, config.concurrency);
     if (!workspaceRoot) {
         return;
     }

package/lib/commands/cache/pruneCache.js

@@ -7,14 +7,13 @@ Object.defineProperty(exports, "pruneCache", {
     get: ()=>pruneCache
 });
 const _workspaceTools = require("workspace-tools");
-const _getConfigJs = require("../../config/getConfig.js");
-const _getConcurrencyJs = require("../../config/getConcurrency.js");
+const _config = require("@lage-run/config");
 const _cache = require("@lage-run/cache");
 async function pruneCache(options) {
     const { logger , cwd , pruneDays  } = options;
-    const config = await (0, _getConfigJs.getConfig)(cwd);
+    const config = await (0, _config.getConfig)(cwd);
     const workspaceRoot = (0, _workspaceTools.getWorkspaceRoot)(cwd);
-    const concurrency = (0, _getConcurrencyJs.getConcurrency)(options.concurrency, config.concurrency);
+    const concurrency = (0, _config.getConcurrency)(options.concurrency, config.concurrency);
     if (!workspaceRoot) {
         return;
     }

package/lib/commands/run/createTargetGraph.d.ts

@@ -1,6 +1,6 @@
 import type { Logger } from "@lage-run/logger";
 import type { PackageInfos } from "workspace-tools";
-import type { PipelineDefinition } from "../../types/PipelineDefinition.js";
+import type { PipelineDefinition } from "@lage-run/config";
 interface CreateTargetGraphOptions {
     logger: Logger;
     root: string;

package/lib/commands/run/filterPipelineDefinitions.d.ts

@@ -1,3 +1,3 @@
 import type { Target } from "@lage-run/target-graph";
-import type { PipelineDefinition } from "../../types/PipelineDefinition.js";
+import type { PipelineDefinition } from "@lage-run/config";
 export declare function filterPipelineDefinitions(targets: IterableIterator<Target>, pipeline: PipelineDefinition): PipelineDefinition;

package/lib/commands/run/infoAction.js

@@ -6,10 +6,9 @@ Object.defineProperty(exports, "infoAction", {
     enumerable: true,
     get: ()=>infoAction
 });
-const _createCacheProviderJs = require("./createCacheProvider.js");
 const _createTargetGraphJs = require("./createTargetGraph.js");
 const _filterArgsForTasksJs = require("./filterArgsForTasks.js");
-const _getConfigJs = require("../../config/getConfig.js");
+const _config = require("@lage-run/config");
 const _workspaceTools = require("workspace-tools");
 const _logger = /*#__PURE__*/ _interopRequireDefault(require("@lage-run/logger"));
 const _targetGraph = require("@lage-run/target-graph");
@@ -20,12 +19,12 @@ function _interopRequireDefault(obj) {
 }
 async function infoAction(options, command) {
     const cwd = process.cwd();
-    const config = await (0, _getConfigJs.getConfig)(cwd);
+    const config = await (0, _config.getConfig)(cwd);
     const logger = (0, _logger.default)();
     // Build Target Graph
     const root = (0, _workspaceTools.getWorkspaceRoot)(process.cwd());
     const packageInfos = (0, _workspaceTools.getPackageInfos)(root);
-    const { tasks , taskArgs  } = (0, _filterArgsForTasksJs.filterArgsForTasks)(command.args);
+    const { tasks  } = (0, _filterArgsForTasksJs.filterArgsForTasks)(command.args);
     const targetGraph = (0, _createTargetGraphJs.createTargetGraph)({
         logger,
         root,
@@ -42,13 +41,6 @@ async function infoAction(options, command) {
     });
     // Make sure we do not attempt writeRemoteCache in info mode
     config.cacheOptions.writeRemoteCache = false;
-    const { hasher  } = (0, _createCacheProviderJs.createCache)({
-        root,
-        logger,
-        cacheOptions: config.cacheOptions,
-        skipLocalCache: false,
-        cliArgs: taskArgs
-    });
     const { targets  } = targetGraph;
     for (const target of targets.values()){
         if (target.id === (0, _targetGraph.getStartTargetId)()) {
@@ -56,9 +48,6 @@ async function infoAction(options, command) {
         }
         const startIdIndex = target.dependencies.indexOf((0, _targetGraph.getStartTargetId)());
         target.dependencies.splice(startIdIndex, 1);
-        process.stdout.write(`${JSON.stringify({
-            ...target,
-            hash: await hasher.hash(target)
-        })}\n`);
+        process.stdout.write(`${JSON.stringify(target)}\n`);
     }
 }

package/lib/commands/run/runAction.js

@@ -6,18 +6,15 @@ Object.defineProperty(exports, "runAction", {
     enumerable: true,
     get: ()=>runAction
 });
-const _createCacheProviderJs = require("./createCacheProvider.js");
 const _createTargetGraphJs = require("./createTargetGraph.js");
 const _filterArgsForTasksJs = require("./filterArgsForTasks.js");
 const _filterPipelineDefinitionsJs = require("./filterPipelineDefinitions.js");
 const _findNpmClient = require("@lage-run/find-npm-client");
-const _getConfigJs = require("../../config/getConfig.js");
-const _getMaxWorkersPerTaskJs = require("../../config/getMaxWorkersPerTask.js");
+const _config = require("@lage-run/config");
 const _workspaceTools = require("workspace-tools");
 const _initializeReportersJs = require("../initializeReporters.js");
 const _scheduler = require("@lage-run/scheduler");
 const _logger = /*#__PURE__*/ _interopRequireDefault(require("@lage-run/logger"));
-const _getConcurrencyJs = require("../../config/getConcurrency.js");
 const _errorsJs = require("../../types/errors.js");
 function _interopRequireDefault(obj) {
     return obj && obj.__esModule ? obj : {
@@ -26,9 +23,9 @@ function _interopRequireDefault(obj) {
 }
 async function runAction(options, command) {
     const cwd = process.cwd();
-    const config = await (0, _getConfigJs.getConfig)(cwd);
+    const config = await (0, _config.getConfig)(cwd);
     // Merged options
-    const concurrency = (0, _getConcurrencyJs.getConcurrency)(options.concurrency, config.concurrency);
+    const concurrency = (0, _config.getConcurrency)(options.concurrency, config.concurrency);
     const allowNoTargetRuns = options.allowNoTargetRuns || config.allowNoTargetRuns;
     // Configure logger
     const logger = (0, _logger.default)();
@@ -55,49 +52,45 @@ async function runAction(options, command) {
         packageInfos
     });
     validateTargetGraph(targetGraph, allowNoTargetRuns);
-    const { cacheProvider , hasher  } = (0, _createCacheProviderJs.createCache)({
-        root,
-        logger,
-        cacheOptions: config.cacheOptions,
-        skipLocalCache: options.skipLocalCache,
-        cliArgs: taskArgs
-    });
     logger.verbose(`Running with ${concurrency} workers`);
     const filteredPipeline = (0, _filterPipelineDefinitionsJs.filterPipelineDefinitions)(targetGraph.targets.values(), config.pipeline);
-    const maxWorkersPerTaskMap = (0, _getMaxWorkersPerTaskJs.getMaxWorkersPerTaskFromOptions)(options.maxWorkersPerTask);
+    const maxWorkersPerTaskMap = (0, _config.getMaxWorkersPerTaskFromOptions)(options.maxWorkersPerTask);
     const scheduler = new _scheduler.SimpleScheduler({
         logger,
         concurrency,
-        cacheProvider,
-        hasher,
         continueOnError: options.continue,
         shouldCache: options.cache,
         shouldResetCache: options.resetCache,
+        workerData: {
+            root,
+            taskArgs,
+            skipLocalCache: options.skipLocalCache,
+            runners: {
+                npmScript: {
+                    script: require.resolve("./runners/NpmScriptRunner.js"),
+                    options: {
+                        nodeArg: options.nodeArg,
+                        taskArgs,
+                        npmCmd: (0, _findNpmClient.findNpmClient)(config.npmClient)
+                    }
+                },
+                worker: {
+                    script: require.resolve("./runners/WorkerRunner.js"),
+                    options: {
+                        taskArgs
+                    }
+                },
+                noop: {
+                    script: require.resolve("./runners/NoOpRunner.js"),
+                    options: {}
+                },
+                ...config.runners
+            }
+        },
         maxWorkersPerTask: new Map([
-            ...(0, _getMaxWorkersPerTaskJs.getMaxWorkersPerTask)(filteredPipeline, concurrency),
+            ...(0, _config.getMaxWorkersPerTask)(filteredPipeline, concurrency),
             ...maxWorkersPerTaskMap
         ]),
-        runners: {
-            npmScript: {
-                script: require.resolve("./runners/NpmScriptRunner.js"),
-                options: {
-                    nodeArg: options.nodeArg,
-                    taskArgs,
-                    npmCmd: (0, _findNpmClient.findNpmClient)(config.npmClient)
-                }
-            },
-            worker: {
-                script: require.resolve("./runners/WorkerRunner.js"),
-                options: {
-                    taskArgs
-                }
-            },
-            noop: {
-                script: require.resolve("./runners/NoOpRunner.js"),
-                options: {}
-            },
-            ...config.runners
-        },
         workerIdleMemoryLimit: config.workerIdleMemoryLimit
     });
     const summary = await scheduler.run(root, targetGraph);

package/lib/commands/run/watchAction.js

@@ -6,19 +6,16 @@ Object.defineProperty(exports, "watchAction", {
     enumerable: true,
     get: ()=>watchAction
 });
-const _createCacheProviderJs = require("./createCacheProvider.js");
 const _createTargetGraphJs = require("./createTargetGraph.js");
 const _filterArgsForTasksJs = require("./filterArgsForTasks.js");
 const _findNpmClient = require("@lage-run/find-npm-client");
-const _getConfigJs = require("../../config/getConfig.js");
-const _getMaxWorkersPerTaskJs = require("../../config/getMaxWorkersPerTask.js");
+const _config = require("@lage-run/config");
 const _workspaceTools = require("workspace-tools");
 const _filterPipelineDefinitionsJs = require("./filterPipelineDefinitions.js");
 const _reporters = require("@lage-run/reporters");
 const _scheduler = require("@lage-run/scheduler");
 const _watcherJs = require("./watcher.js");
 const _logger = /*#__PURE__*/ _interopRequireWildcard(require("@lage-run/logger"));
-const _getConcurrencyJs = require("../../config/getConcurrency.js");
 function _getRequireWildcardCache(nodeInterop) {
     if (typeof WeakMap !== "function") return null;
     var cacheBabelInterop = new WeakMap();
@@ -60,8 +57,8 @@ function _interopRequireWildcard(obj, nodeInterop) {
 }
 async function watchAction(options, command) {
     const cwd = process.cwd();
-    const config = await (0, _getConfigJs.getConfig)(cwd);
-    const concurrency = (0, _getConcurrencyJs.getConcurrency)(options.concurrency, config.concurrency);
+    const config = await (0, _config.getConfig)(cwd);
+    const concurrency = (0, _config.getConcurrency)(options.concurrency, config.concurrency);
     // Configure logger
     const logger = (0, _logger.default)();
     const reporter = new _reporters.LogReporter({
@@ -88,48 +85,44 @@ async function watchAction(options, command) {
     });
     // Make sure we do not attempt writeRemoteCache in watch mode
     config.cacheOptions.writeRemoteCache = false;
-    const { cacheProvider , hasher  } = (0, _createCacheProviderJs.createCache)({
-        root,
-        logger,
-        cacheOptions: config.cacheOptions,
-        skipLocalCache: false,
-        cliArgs: taskArgs
-    });
     const filteredPipeline = (0, _filterPipelineDefinitionsJs.filterPipelineDefinitions)(targetGraph.targets.values(), config.pipeline);
-    const maxWorkersPerTaskMap = (0, _getMaxWorkersPerTaskJs.getMaxWorkersPerTaskFromOptions)(options.maxWorkersPerTask);
+    const maxWorkersPerTaskMap = (0, _config.getMaxWorkersPerTaskFromOptions)(options.maxWorkersPerTask);
     const scheduler = new _scheduler.SimpleScheduler({
         logger,
         concurrency,
-        cacheProvider,
-        hasher,
         continueOnError: true,
+        workerData: {
+            root,
+            taskArgs,
+            skipLocalCache: options.skipLocalCache,
+            runners: {
+                npmScript: {
+                    script: require.resolve("./runners/NpmScriptRunner.js"),
+                    options: {
+                        nodeArg: options.nodeArg,
+                        taskArgs,
+                        npmCmd: (0, _findNpmClient.findNpmClient)(config.npmClient)
+                    }
+                },
+                worker: {
+                    script: require.resolve("./runners/WorkerRunner.js"),
+                    options: {
+                        taskArgs
+                    }
+                },
+                noop: {
+                    script: require.resolve("./runners/NoOpRunner.js"),
+                    options: {}
+                },
+                ...config.runners
+            }
+        },
         shouldCache: options.cache,
         shouldResetCache: options.resetCache,
         maxWorkersPerTask: new Map([
-            ...(0, _getMaxWorkersPerTaskJs.getMaxWorkersPerTask)(filteredPipeline, concurrency),
+            ...(0, _config.getMaxWorkersPerTask)(filteredPipeline, concurrency),
             ...maxWorkersPerTaskMap
         ]),
-        runners: {
-            npmScript: {
-                script: require.resolve("./runners/NpmScriptRunner.js"),
-                options: {
-                    nodeArg: options.nodeArg,
-                    taskArgs,
-                    npmCmd: (0, _findNpmClient.findNpmClient)(config.npmClient)
-                }
-            },
-            worker: {
-                script: require.resolve("./runners/WorkerRunner.js"),
-                options: {
-                    taskArgs
-                }
-            },
-            noop: {
-                script: require.resolve("./runners/NoOpRunner.js"),
-                options: {}
-            },
-            ...config.runners
-        },
         workerIdleMemoryLimit: config.workerIdleMemoryLimit
     });
     // Initial run
@@ -139,8 +132,6 @@ async function watchAction(options, command) {
     // Disables cache for subsequent runs
     // TODO: support updating hasher + write-only local cacheProvider for subsequent runs
     for (const targetRun of scheduler.targetRuns.values()){
-        targetRun.options.cacheProvider = undefined;
-        targetRun.options.hasher = undefined;
         targetRun.options.shouldCache = false;
     }
     // When initial run is done, disable fetching of caches on all targets, keep writing to the cache

package/lib/index.d.ts

@@ -1,7 +1,7 @@
-export type { CacheOptions } from "./types/CacheOptions.js";
-export type { ConfigOptions } from "./types/ConfigOptions.js";
-export type { Priority } from "./types/Priority.js";
-export type { PipelineDefinition } from "./types/PipelineDefinition.js";
-export type { LoggerOptions } from "./types/LoggerOptions.js";
-export type { TargetRunnerPickerOptions } from "@lage-run/scheduler";
+export type { CacheOptions } from "@lage-run/config";
+export type { ConfigOptions } from "@lage-run/config";
+export type { Priority } from "@lage-run/config";
+export type { PipelineDefinition } from "@lage-run/config";
+export type { LoggerOptions } from "@lage-run/config";
+export type { TargetRunnerPickerOptions } from "@lage-run/scheduler-types";
 export type { TargetConfig } from "@lage-run/target-graph";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/cli",
-  "version": "0.11.3",
+  "version": "0.12.0",
   "description": "Command Line Interface for Lage",
   "repository": {
     "url": "https://github.com/microsoft/lage"
@@ -18,23 +18,22 @@
     "lint": "monorepo-scripts lint"
   },
   "dependencies": {
+    "@lage-run/config": "^0.1.1",
     "@lage-run/find-npm-client": "^0.1.4",
     "@lage-run/logger": "^1.2.2",
-    "@lage-run/scheduler": "^0.10.4",
-    "@lage-run/scheduler-types": "^0.3.4",
+    "@lage-run/scheduler": "^0.11.0",
+    "@lage-run/scheduler-types": "^0.3.5",
     "@lage-run/target-graph": "^0.8.1",
     "@lage-run/cache": "^0.5.1",
-    "@lage-run/reporters": "^1.0.6",
+    "@lage-run/reporters": "^1.0.7",
     "commander": "^9.4.0",
     "workspace-tools": "^0.30.0",
     "chokidar": "3.5.3",
-    "fast-glob": "^3.2.11",
-    "cosmiconfig": "^7.0.0"
+    "fast-glob": "^3.2.11"
   },
   "devDependencies": {
     "monorepo-scripts": "*",
-    "@lage-run/monorepo-fixture": "*",
-    "backfill-config": "6.3.1"
+    "@lage-run/monorepo-fixture": "*"
   },
   "publishConfig": {
     "access": "public"

package/lib/commands/run/createCacheProvider.d.ts

@@ -1,15 +0,0 @@
-import type { CacheOptions } from "@lage-run/cache";
-import { RemoteFallbackCacheProvider, TargetHasher } from "@lage-run/cache";
-import type { Logger } from "@lage-run/logger";
-interface CreateCacheOptions {
-    cacheOptions?: CacheOptions;
-    logger: Logger;
-    root: string;
-    skipLocalCache: boolean;
-    cliArgs: string[];
-}
-export declare function createCache(options: CreateCacheOptions): {
-    cacheProvider: RemoteFallbackCacheProvider;
-    hasher: TargetHasher;
-};
-export {};

package/lib/commands/run/createCacheProvider.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "createCache", {
-    enumerable: true,
-    get: ()=>createCache
-});
-const _cache = require("@lage-run/cache");
-const _isRunningFromCIJs = require("../isRunningFromCI.js");
-function createCache(options) {
-    const { cacheOptions , logger , root , skipLocalCache , cliArgs  } = options;
-    const hasRemoteCacheConfig = !!cacheOptions?.cacheStorageConfig || !!process.env.BACKFILL_CACHE_PROVIDER || !!process.env.BACKFILL_CACHE_PROVIDER_OPTIONS;
-    // Create Cache Provider
-    const cacheProvider = new _cache.RemoteFallbackCacheProvider({
-        root,
-        logger,
-        localCacheProvider: skipLocalCache === true ? undefined : new _cache.BackfillCacheProvider({
-            logger,
-            root,
-            cacheOptions: {
-                outputGlob: cacheOptions?.outputGlob,
-                ...cacheOptions?.internalCacheFolder && {
-                    internalCacheFolder: cacheOptions.internalCacheFolder
-                },
-                ...cacheOptions?.incrementalCaching && {
-                    incrementalCaching: cacheOptions.incrementalCaching
-                }
-            }
-        }),
-        remoteCacheProvider: hasRemoteCacheConfig ? new _cache.BackfillCacheProvider({
-            logger,
-            root,
-            cacheOptions: cacheOptions ?? {}
-        }) : undefined,
-        writeRemoteCache: cacheOptions?.writeRemoteCache === true || String(process.env.LAGE_WRITE_CACHE).toLowerCase() === "true" || _isRunningFromCIJs.isRunningFromCI
-    });
-    const hasher = new _cache.TargetHasher({
-        root,
-        environmentGlob: cacheOptions?.environmentGlob ?? [],
-        cacheKey: cacheOptions?.cacheKey,
-        cliArgs
-    });
-    return {
-        cacheProvider,
-        hasher
-    };
-}

package/lib/config/getConcurrency.d.ts

@@ -1 +0,0 @@
-export declare function getConcurrency(optionsConcurrency: number | undefined, configConcurrency: number | undefined): number;

package/lib/config/getConcurrency.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getConcurrency", {
-    enumerable: true,
-    get: ()=>getConcurrency
-});
-const _os = /*#__PURE__*/ _interopRequireDefault(require("os"));
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-function getConcurrency(optionsConcurrency, configConcurrency) {
-    return optionsConcurrency || configConcurrency || _os.default.cpus().length - 1;
-}

package/lib/config/getConfig.d.ts

@@ -1,2 +0,0 @@
-import type { ConfigOptions } from "../types/ConfigOptions.js";
-export declare function getConfig(cwd: string): Promise<ConfigOptions>;

package/lib/config/getConfig.js

@@ -1,48 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "getConfig", {
-    enumerable: true,
-    get: ()=>getConfig
-});
-const _os = /*#__PURE__*/ _interopRequireDefault(require("os"));
-const _cosmiconfig = require("cosmiconfig");
-const _workspaceTools = require("workspace-tools");
-function _interopRequireDefault(obj) {
-    return obj && obj.__esModule ? obj : {
-        default: obj
-    };
-}
-async function getConfig(cwd) {
-    // Verify presence of git
-    const root = (0, _workspaceTools.getWorkspaceRoot)(cwd);
-    if (!root) {
-        throw new Error("This must be called inside a codebase that is part of a JavaScript workspace.");
-    }
-    // Search for lage.config.js file
-    const ConfigModuleName = "lage";
-    const configExplorer = await (0, _cosmiconfig.cosmiconfig)(ConfigModuleName);
-    const results = await configExplorer.search(root ?? cwd);
-    const config = results?.config;
-    return {
-        cacheOptions: config?.cacheOptions ?? {},
-        ignore: config?.ignore ?? [],
-        npmClient: config?.npmClient ?? "npm",
-        pipeline: config?.pipeline ?? {},
-        priorities: config?.priorities ?? [],
-        repoWideChanges: config?.repoWideChanges ?? [
-            "lage.config.js",
-            "package-lock.json",
-            "yarn.lock",
-            "pnpm-lock.yaml",
-            "lerna.json",
-            "rush.json"
-        ],
-        loggerOptions: config?.loggerOptions ?? {},
-        runners: config?.runners ?? {},
-        workerIdleMemoryLimit: config?.workerIdleMemoryLimit ?? _os.default.totalmem(),
-        concurrency: config?.concurrency ?? _os.default.cpus().length - 1,
-        allowNoTargetRuns: config?.allowNoTargetRuns ?? false
-    };
-}

package/lib/config/getMaxWorkersPerTask.d.ts

@@ -1,3 +0,0 @@
-import type { ConfigOptions } from "../types/ConfigOptions.js";
-export declare function getMaxWorkersPerTask(pipelineConfig: ConfigOptions["pipeline"], concurrency: number): Map<string, number>;
-export declare function getMaxWorkersPerTaskFromOptions(maxWorkersPerTask: string[]): Map<string, number>;

package/lib/config/getMaxWorkersPerTask.js

@@ -1,68 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    getMaxWorkersPerTask: ()=>getMaxWorkersPerTask,
-    getMaxWorkersPerTaskFromOptions: ()=>getMaxWorkersPerTaskFromOptions
-});
-function getMaxWorkersPerTask(pipelineConfig, concurrency) {
-    const maxWorkersPerTask = new Map();
-    let generalPoolCount = 0;
-    let generatelPoolMaxWorkers = 0;
-    let dedicatedPoolCount = 0;
-    let dedicatedPoolMaxWorkers = 0;
-    for (const [task, taskConfig] of Object.entries(pipelineConfig)){
-        if (!Array.isArray(taskConfig) && !task.includes("#")) {
-            const maxWorkerOption = taskConfig.maxWorkers ?? taskConfig.options?.maxWorkers;
-            if (typeof maxWorkerOption === "undefined") {
-                generalPoolCount++;
-                continue;
-            }
-            let maxWorkers = 0;
-            if (typeof maxWorkerOption !== "number") {
-                throw new Error(`Invalid maxWorkers value: ${maxWorkerOption}`);
-            } else {
-                maxWorkers = maxWorkerOption;
-            }
-            maxWorkersPerTask.set(task, maxWorkers);
-            dedicatedPoolCount++;
-            dedicatedPoolMaxWorkers += maxWorkers;
-        }
-    }
-    if (dedicatedPoolCount > 0 && generalPoolCount > 0) {
-        const avgMaxWorkers = dedicatedPoolMaxWorkers / dedicatedPoolCount;
-        generatelPoolMaxWorkers = Math.max(1, Math.floor(avgMaxWorkers * generalPoolCount));
-    }
-    const grandTotal = dedicatedPoolMaxWorkers + generatelPoolMaxWorkers;
-    // try to adjust the maxWorkersPerTask to fit the concurrency
-    if (grandTotal > concurrency) {
-        let newTotal = 0;
-        for (const [task, maxWorkers] of maxWorkersPerTask.entries()){
-            const newMaxWorkers = Math.max(1, Math.floor(maxWorkers / grandTotal * concurrency));
-            newTotal += newMaxWorkers;
-            maxWorkersPerTask.set(task, newMaxWorkers);
-        }
-        if (newTotal > concurrency) {
-            throw new Error("Could not adjust maxWorkers per task to fit the concurrency, try reducing the maxWorkers, or increasing the --concurrency CLI argument, or separate the tasks to be run");
-        }
-    }
-    return maxWorkersPerTask;
-}
-function getMaxWorkersPerTaskFromOptions(maxWorkersPerTask) {
-    return new Map([
-        ...maxWorkersPerTask.map((setting)=>{
-            const [task, maxWorkers] = setting.split(/[=:]/);
-            return [
-                task,
-                parseInt(maxWorkers, 10)
-            ];
-        })
-    ]);
-}

package/lib/types/CacheOptions.d.ts

@@ -1,7 +0,0 @@
-import type { Config as BackfillCacheOptions } from "backfill-config";
-export type CacheOptions = BackfillCacheOptions & {
-    environmentGlob: string[];
-    cacheKey: string;
-    writeRemoteCache: boolean;
-    skipLocalCache: boolean;
-};

package/lib/types/CacheOptions.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/lib/types/ConfigOptions.d.ts

@@ -1,56 +0,0 @@
-import type { CacheOptions } from "./CacheOptions.js";
-import type { Priority } from "./Priority.js";
-import type { PipelineDefinition } from "./PipelineDefinition.js";
-import type { LoggerOptions } from "./LoggerOptions.js";
-import type { TargetRunnerPickerOptions } from "@lage-run/scheduler";
-export type NpmClient = "npm" | "yarn" | "pnpm";
-export interface ConfigOptions {
-    /**
-     * Defines the task pipeline, prefix with "^" character to denote a direct topological dependency,
-     * prefix with ^^ to denote a transitive topological dependency.
-     *
-     * Example:
-     *
-     * ```
-     * {
-     *   build: ["^build"],
-     *   test: ["build"],
-     *   lint: []
-     *   bundle: ["^^transpile"],
-     *   transpile: [],
-     * }
-     * ```
-     */
-    pipeline: PipelineDefinition;
-    /** Backfill cache options */
-    cacheOptions: CacheOptions;
-    /** Which files to ignore when calculating scopes with --since */
-    ignore: string[];
-    /** disables --since flag when any of this list of files changed */
-    repoWideChanges: string[];
-    /** Which NPM Client to use when running npm lifecycle scripts */
-    npmClient: NpmClient;
-    /** Optional priority to set on tasks in a package to make the scheduler give priority to tasks on the critical path for high priority tasks */
-    priorities: Priority[];
-    /**
-     * Options that will be sent to all log reporters.
-     */
-    loggerOptions: LoggerOptions;
-    /**
-     * Custom runners for tasks in the pipeline. The key is the task name, and the value is a configuration describing what would be
-     * passed to the runner constructor.
-     */
-    runners: TargetRunnerPickerOptions;
-    /**
-     * Maximum worker idle memory, this would cause workers to restart if they exceed this limit. This is useful to prevent memory leaks.
-     */
-    workerIdleMemoryLimit: number;
-    /**
-     * Maximum number of concurrent tasks to run
-     */
-    concurrency: number;
-    /**
-     * Allows for no targets run
-     */
-    allowNoTargetRuns: boolean;
-}

package/lib/types/ConfigOptions.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/lib/types/LoggerOptions.d.ts

@@ -1,15 +0,0 @@
-import type { LogLevel } from "@lage-run/logger";
-export interface LoggerOptions {
-    disp?: {
-        [level: string]: string;
-    };
-    style?: {
-        [level: string]: {
-            fg?: string;
-            bg?: string;
-        };
-    };
-    levels?: {
-        [level: string]: LogLevel;
-    };
-}

package/lib/types/LoggerOptions.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/lib/types/PipelineDefinition.d.ts

@@ -1,12 +0,0 @@
-import type { TargetConfig } from "@lage-run/target-graph";
-import type { ConfigOptions } from "./ConfigOptions.js";
-export interface FactoryArgs {
-    cwd: string;
-    config: ConfigOptions;
-}
-export interface TargetConfigFactory {
-    (args: FactoryArgs): TargetConfig | TargetConfig[];
-}
-export interface PipelineDefinition {
-    [task: string]: string[] | TargetConfig;
-}

package/lib/types/PipelineDefinition.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});

package/lib/types/Priority.d.ts

@@ -1,8 +0,0 @@
-export interface Priority {
-    /** package name, as in package.json */
-    package?: string;
-    /** task name, as listed in the `scripts` section of package.json */
-    task: string;
-    /** priority, the higher the more priority; undefined priority means lowest priority*/
-    priority: number;
-}

package/lib/types/Priority.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});