@lage-run/cli 0.11.4 → 0.13.0

package/CHANGELOG.json

@@ -2,7 +2,49 @@
   "name": "@lage-run/cli",
   "entries": [
     {
-      "date": "Wed, 29 Mar 2023 22:41:31 GMT",
+      "date": "Sat, 01 Apr 2023 00:28:19 GMT",
+      "tag": "@lage-run/cli_v0.13.0",
+      "version": "0.13.0",
+      "comments": {
+        "minor": [
+          {
+            "author": "kchau@microsoft.com",
+            "package": "@lage-run/cli",
+            "commit": "884c8b5aba15cd1cc5f943c06a6a9da4af20f806",
+            "comment": "replace ink with @ms-cloudpack/task-reporter"
+          },
+          {
+            "author": "beachball",
+            "package": "@lage-run/cli",
+            "comment": "Bump @lage-run/reporters to v1.1.0",
+            "commit": "884c8b5aba15cd1cc5f943c06a6a9da4af20f806"
+          }
+        ]
+      }
+    },
+    {
+      "date": "Thu, 30 Mar 2023 23:46:52 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": {

package/CHANGELOG.md

@@ -1,12 +1,30 @@
 # Change Log - @lage-run/cli
 
-This log was last generated on Wed, 29 Mar 2023 22:41:31 GMT and should not be manually modified.
+This log was last generated on Sat, 01 Apr 2023 00:28:19 GMT and should not be manually modified.
 
 <!-- Start content -->
 
+## 0.13.0
+
+Sat, 01 Apr 2023 00:28:19 GMT
+
+### Minor changes
+
+- replace ink with @ms-cloudpack/task-reporter (kchau@microsoft.com)
+- Bump @lage-run/reporters to v1.1.0
+
+## 0.12.0
+
+Thu, 30 Mar 2023 23:46:52 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:31 GMT
+Wed, 29 Mar 2023 22:41:49 GMT
 
 ### Patches
 

package/lib/commands/createReporter.js

@@ -8,9 +8,20 @@ Object.defineProperty(exports, "createReporter", {
 });
 const _logger = require("@lage-run/logger");
 const _reporters = require("@lage-run/reporters");
+const _workspaceTools = require("workspace-tools");
+const _fs = require("fs");
+const _path = /*#__PURE__*/ _interopRequireDefault(require("path"));
+function _interopRequireDefault(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function createReporter(reporter, options) {
     const { verbose , grouped , logLevel: logLevelName , concurrency , profile , progress  } = options;
     const logLevel = _logger.LogLevel[logLevelName];
+    const root = (0, _workspaceTools.findPackageRoot)(__filename);
+    const packageJson = JSON.parse((0, _fs.readFileSync)(_path.default.join(root, "package.json"), "utf-8"));
+    const version = packageJson.version;
     switch(reporter){
         case "profile":
             return new _reporters.ChromeTraceEventsReporter({
@@ -36,7 +47,8 @@ function createReporter(reporter, options) {
         default:
             if (progress && !(logLevel >= _logger.LogLevel.verbose || verbose || grouped)) {
                 return new _reporters.ProgressReporter({
-                    concurrency
+                    concurrency,
+                    version
                 });
             }
             return new _reporters.LogReporter({

package/lib/commands/run/infoAction.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "infoAction", {
     enumerable: true,
     get: ()=>infoAction
 });
-const _createCacheProviderJs = require("./createCacheProvider.js");
 const _createTargetGraphJs = require("./createTargetGraph.js");
 const _filterArgsForTasksJs = require("./filterArgsForTasks.js");
 const _config = require("@lage-run/config");
@@ -25,7 +24,7 @@ async function infoAction(options, command) {
     // 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,7 +6,6 @@ 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");
@@ -53,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, _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, _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,7 +6,6 @@ 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");
@@ -86,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, _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, _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
@@ -137,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lage-run/cli",
-  "version": "0.11.4",
+  "version": "0.13.0",
   "description": "Command Line Interface for Lage",
   "repository": {
     "url": "https://github.com/microsoft/lage"
@@ -21,11 +21,11 @@
     "@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.5",
+    "@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.7",
+    "@lage-run/reporters": "^1.1.0",
     "commander": "^9.4.0",
     "workspace-tools": "^0.30.0",
     "chokidar": "3.5.3",

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
-    };
-}