@memlab/cli 1.0.23 → 1.0.24

package/dist/BaseCommand.d.ts

@@ -27,6 +27,7 @@ export default class BaseCommand extends Command {
     getExamples(): string[];
     getCategory(): CommandCategory;
     getDescription(): string;
+    getDocumenation(): string;
     getPrerequisites(): BaseCommand[];
     isInternalCommand(): boolean;
     getOptions(): BaseOption[];

package/dist/BaseCommand.js

@@ -101,6 +101,12 @@ class BaseCommand extends Command {
         const className = this.constructor.name;
         throw new Error(`${className}.getDescription is not implemented`);
     }
+    // More detailed description or documentation about this command.
+    // This will be printed as helper text in CLI for a specific command.
+    // Documentation generator will also use the description returned here.
+    getDocumenation() {
+        return '';
+    }
     // get a sequence of commands that must be executed before
     // running this command
     getPrerequisites() {

package/dist/commands/RunMeasureCommand.js

@@ -86,9 +86,8 @@ class RunMeasureCommand extends BaseCommand_1.default {
         ];
     }
     run(options) {
-        var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            const numRuns = (_b = (_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.numOfRuns) !== null && _b !== void 0 ? _b : NumberOfRunsOption_1.default.DEFAULT_NUM_RUNS;
+            const numRuns = NumberOfRunsOption_1.default.getParsedOption(options.configFromOptions);
             core_1.config.runningMode = core_1.modes.get('measure', core_1.config);
             for (let i = 0; i < numRuns; ++i) {
                 yield (0, Snapshot_1.runPageInteractionFromCLI)();

package/dist/commands/heap/CheckLeakCommand.d.ts

@@ -7,11 +7,21 @@
  * @format
  * @oncall web_perf_infra
  */
+import type { ParsedArgs } from 'minimist';
 import type { BaseOption, CLIOptions } from '@memlab/core';
 import BaseCommand, { CommandCategory } from '../../BaseCommand';
+export declare type CheckLeakCommandOptions = {
+    isMLClustering?: boolean;
+};
 export default class CheckLeakCommand extends BaseCommand {
+    private isMLClustering;
+    private isMLClusteringSettingCache;
+    protected useDefaultMLClusteringSetting(cliArgs: ParsedArgs): void;
+    protected restoreDefaultMLClusteringSetting(cliArgs: ParsedArgs): void;
+    constructor(options?: CheckLeakCommandOptions);
     getCommandName(): string;
     getDescription(): string;
+    getDocumenation(): string;
     getCategory(): CommandCategory;
     getPrerequisites(): BaseCommand[];
     getOptions(): BaseOption[];

package/dist/commands/heap/CheckLeakCommand.js

@@ -1,13 +1,4 @@
 "use strict";
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @format
- * @oncall web_perf_infra
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -64,12 +55,37 @@ const MLClusteringMaxDFOption_1 = __importDefault(require("../../options/MLClust
 const CleanupSnapshotOption_1 = __importDefault(require("../../options/heap/CleanupSnapshotOption"));
 const SetWorkingDirectoryOption_1 = __importDefault(require("../../options/SetWorkingDirectoryOption"));
 class CheckLeakCommand extends BaseCommand_1.default {
+    constructor(options = {}) {
+        super();
+        this.isMLClustering = false;
+        this.isMLClusteringSettingCache = false;
+        this.isMLClustering = !!(options === null || options === void 0 ? void 0 : options.isMLClustering);
+    }
+    useDefaultMLClusteringSetting(cliArgs) {
+        if (!MLClusteringOption_1.default.hasOptionSet(cliArgs)) {
+            core_1.config.isMLClustering = this.isMLClustering;
+            this.isMLClusteringSettingCache = core_1.config.isMLClustering;
+        }
+    }
+    restoreDefaultMLClusteringSetting(cliArgs) {
+        if (!MLClusteringOption_1.default.hasOptionSet(cliArgs)) {
+            core_1.config.isMLClustering = this.isMLClusteringSettingCache;
+        }
+    }
     getCommandName() {
         return 'find-leaks';
     }
     getDescription() {
         return 'find memory leaks in heap snapshots';
     }
+    getDocumenation() {
+        return `There are three ways to specify inputs for the \`memlab find-leaks\` command:
+ 1. \`--baseline\`, \`--target\`, \`--final\` specifies each snapshot input individually;
+ 2. \`--snapshot-dir\` specifies the directory that holds all three heap snapshot files (MemLab will assign baseline, target, and final based on alphabetic order of the file);
+ 3. \`--work-dir\` specifies the output working directory of the \`memlab run\` or the \`memlab snapshot\` command;
+
+Please only use one of the three ways to specify the input.`;
+    }
     getCategory() {
         return BaseCommand_1.CommandCategory.COMMON;
     }
@@ -100,8 +116,15 @@ class CheckLeakCommand extends BaseCommand_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             const workDir = (_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.workDir;
             core_1.fileManager.initDirs(core_1.config, { workDir });
+            const { runMetaInfoManager } = core_1.runInfoUtils;
+            runMetaInfoManager.setConfigFromRunMeta({
+                workDir,
+                silentFail: true,
+            });
             core_1.config.chaseWeakMapEdge = false;
+            this.useDefaultMLClusteringSetting(options.cliArgs);
             yield core_1.analysis.checkLeak();
+            this.restoreDefaultMLClusteringSetting(options.cliArgs);
             const configFromOptions = (_b = options.configFromOptions) !== null && _b !== void 0 ? _b : {};
             if (configFromOptions['cleanUpSnapshot']) {
                 core_1.fileManager.removeSnapshotFiles();

package/dist/commands/heap/DiffLeakCommand.d.ts

@@ -7,9 +7,8 @@
  * @format
  * @oncall web_perf_infra
  */
-import { CLIOptions } from '@memlab/core';
+import type { BaseOption, CLIOptions } from '@memlab/core';
 import BaseCommand, { CommandCategory } from '../../BaseCommand';
-import { BaseOption } from '@memlab/core';
 export default class CheckLeakCommand extends BaseCommand {
     getCommandName(): string;
     getDescription(): string;

package/dist/commands/heap/DiffLeakCommand.js

@@ -1,13 +1,4 @@
 "use strict";
-/**
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- *
- * @format
- * @oncall web_perf_infra
- */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
     var desc = Object.getOwnPropertyDescriptor(m, k);
@@ -45,9 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@memlab/core");
-const core_2 = require("@memlab/core");
 const BaseCommand_1 = __importStar(require("../../BaseCommand"));
-const core_3 = require("@memlab/core");
 const JSEngineOption_1 = __importDefault(require("../../options/heap/JSEngineOption"));
 const InitDirectoryCommand_1 = __importDefault(require("../InitDirectoryCommand"));
 const OversizeThresholdOption_1 = __importDefault(require("../../options/heap/OversizeThresholdOption"));
@@ -92,18 +81,23 @@ class CheckLeakCommand extends BaseCommand_1.default {
     run(options) {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
-            core_3.config.chaseWeakMapEdge = false;
+            core_1.config.chaseWeakMapEdge = false;
             // double check parameters
-            if (!((_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.controlWorkDir) ||
+            if (!((_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.controlWorkDirs) ||
                 !((_b = options.configFromOptions) === null || _b === void 0 ? void 0 : _b.treatmentWorkDir)) {
-                core_2.info.error('Please specify control and test working directory');
+                core_1.info.error('Please specify control and test working directory');
                 throw core_1.utils.haltOrThrow('No control or test working directory specified');
             }
             // get parameters
-            const controlWorkDir = options.configFromOptions['controlWorkDir'];
+            const controlWorkDirs = options.configFromOptions['controlWorkDirs'];
             const treatmentWorkDir = options.configFromOptions['treatmentWorkDir'];
+            const { runMetaInfoManager } = core_1.runInfoUtils;
+            runMetaInfoManager.setConfigFromRunMeta({
+                workDir: treatmentWorkDir,
+                silentFail: true,
+            });
             // diff memory leaks
-            yield core_3.analysis.diffLeakByWorkDir({ controlWorkDir, treatmentWorkDir });
+            yield core_1.analysis.diffLeakByWorkDir({ controlWorkDirs, treatmentWorkDir });
         });
     }
 }

package/dist/commands/heap/interactive/ui-components/CliScreen.d.ts

@@ -12,6 +12,7 @@ export default class CliScreen {
     private currentFocuseKey;
     private keyToComponent;
     private heapController;
+    private fullScreenComponent;
     constructor(title: string, heap: IHeapSnapshot, objectCategory: Map<string, ComponentDataItem[]>);
     private setFirstObjectAsCurrrent;
     private initScreen;
@@ -19,9 +20,12 @@ export default class CliScreen {
     start(): void;
     private registerEvents;
     private registerScreenResize;
+    private updateAllComponentsSize;
     private updateComponentSize;
     private updateElementSize;
     private registerKeys;
+    private makeComponentFullScreen;
+    private makeNoComponentFullScreen;
     private addComponentToFocusKeyMap;
     private getNextFocusKey;
     private initClusteredObjectBox;
@@ -29,6 +33,7 @@ export default class CliScreen {
     private initReferrerBox;
     private getReferrerBoxSize;
     private initObjectBox;
+    private getComponentFullScreenSize;
     private getObjectBoxSize;
     private initObjectPropertyBox;
     private getObjectPropertyBoxSize;

package/dist/commands/heap/interactive/ui-components/CliScreen.js

@@ -40,6 +40,7 @@ function positionToNumber(info) {
 class CliScreen {
     constructor(title, heap, objectCategory) {
         this.currentFocuseKey = 1;
+        this.fullScreenComponent = null;
         this.heapController = new HeapViewController_1.default(heap, objectCategory);
         this.screen = this.initScreen(title);
         const callbacks = this.initCallbacks(this.heapController, this.screen);
@@ -118,16 +119,20 @@ class CliScreen {
     }
     registerScreenResize() {
         const screen = this.screen;
-        screen.on('resize', () => {
-            // all boxes/lists needs to resize
-            this.updateComponentSize(this.clusteredObjectBox, this.getClusteredObjectBoxSize());
-            this.updateComponentSize(this.referrerBox, this.getReferrerBoxSize());
-            this.updateComponentSize(this.objectBox, this.getObjectBoxSize());
-            this.updateComponentSize(this.objectPropertyBox, this.getObjectPropertyBoxSize());
-            this.updateComponentSize(this.referenceBox, this.getReferenceBoxSize());
-            this.updateComponentSize(this.retainerTraceBox, this.getRetainerTraceBoxSize());
-            this.updateElementSize(this.helperTextElement, this.getHelperTextSize());
-        });
+        screen.on('resize', this.updateAllComponentsSize.bind(this));
+    }
+    updateAllComponentsSize() {
+        // all boxes/lists needs to resize
+        this.updateComponentSize(this.clusteredObjectBox, this.getClusteredObjectBoxSize());
+        this.updateComponentSize(this.referrerBox, this.getReferrerBoxSize());
+        this.updateComponentSize(this.objectBox, this.getObjectBoxSize());
+        this.updateComponentSize(this.objectPropertyBox, this.getObjectPropertyBoxSize());
+        this.updateComponentSize(this.referenceBox, this.getReferenceBoxSize());
+        this.updateComponentSize(this.retainerTraceBox, this.getRetainerTraceBoxSize());
+        if (this.fullScreenComponent != null) {
+            this.updateComponentSize(this.fullScreenComponent, this.getComponentFullScreenSize());
+        }
+        this.updateElementSize(this.helperTextElement, this.getHelperTextSize());
     }
     updateComponentSize(component, size) {
         this.updateElementSize(component.element, size);
@@ -141,7 +146,16 @@ class CliScreen {
     registerKeys() {
         const screen = this.screen;
         // Quit on Escape, q, or Control-C.
-        screen.key(['escape', 'q', 'C-c'], () => process.exit(0));
+        screen.key(['escape', 'q', 'C-c'], () => {
+            if (this.fullScreenComponent != null) {
+                // exit component full screen mode
+                this.makeNoComponentFullScreen();
+            }
+            else {
+                // quit the program
+                process.exit(0);
+            }
+        });
         const keyToComponent = this.keyToComponent;
         const heapController = this.heapController;
         // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -150,13 +164,30 @@ class CliScreen {
                 // focus on the selected element
                 const component = keyToComponent.get(char);
                 if (component) {
+                    if (component !== this.fullScreenComponent) {
+                        // quit full screen mode if the component to focus
+                        // is not the current full screen component
+                        this.makeNoComponentFullScreen();
+                    }
                     heapController.focusOnComponent(component.id);
                     screen.render();
                 }
             }
+            // enter full screen
+            if (char === 'f') {
+                this.makeComponentFullScreen(heapController.getFocusedComponent());
+            }
         };
         screen.on('keypress', callback);
     }
+    makeComponentFullScreen(component) {
+        this.fullScreenComponent = component;
+        this.updateAllComponentsSize();
+    }
+    makeNoComponentFullScreen() {
+        this.fullScreenComponent = null;
+        this.updateAllComponentsSize();
+    }
     addComponentToFocusKeyMap(component) {
         const key = `${this.currentFocuseKey++}`;
         this.keyToComponent.set(key, component);
@@ -208,6 +239,14 @@ class CliScreen {
         this.addComponentToFocusKeyMap(box);
         return box;
     }
+    getComponentFullScreenSize() {
+        return {
+            width: positionToNumber(this.screen.width) - 4,
+            height: positionToNumber(this.screen.height) - 5,
+            top: 2,
+            left: 2,
+        };
+    }
     getObjectBoxSize() {
         return {
             width: Math.floor(positionToNumber(this.screen.width) / 3),
@@ -282,6 +321,7 @@ class CliScreen {
             '←': '',
             '→': '',
             Enter: 'select',
+            f: 'full screen',
             q: 'quit',
         };
         const keysToFocus = Array.from(this.keyToComponent.keys());

package/dist/commands/heap/interactive/ui-components/HeapViewController.d.ts

@@ -22,6 +22,7 @@ export default class HeapViewController {
     private componentIdToDataMap;
     private componentIdToComponentMap;
     private heap;
+    private focusedComponent;
     private clusteredBox;
     private referrerBox;
     private objectBox;
@@ -30,6 +31,7 @@ export default class HeapViewController {
     private retainerTracePropertyBox;
     private scriptManager;
     constructor(heap: IHeapSnapshot, objectCategory: ObjectCategory);
+    getFocusedComponent(): ListComponent;
     private getFlattenHeapObjectsInfo;
     private getFlattenClusteredObjectsInfo;
     private shouldClusterCategory;

package/dist/commands/heap/interactive/ui-components/HeapViewController.js

@@ -27,6 +27,9 @@ class HeapViewController {
         this.scriptManager = new e2e_1.ScriptManager();
         this.scriptManager.loadFromFiles();
     }
+    getFocusedComponent() {
+        return this.focusedComponent;
+    }
     getFlattenHeapObjectsInfo(objectCategory) {
         let ret = [];
         for (const category of objectCategory.keys()) {
@@ -341,7 +344,7 @@ class HeapViewController {
         this.objectBox.setLabel('Objects');
         this.setSelectedHeapObject(node);
         if (!options.skipFocus) {
-            this.focusOnComponent(this.objectBox.id);
+            this.focusOnComponent(this.clusteredBox.id);
         }
     }
     focusOnComponent(componentId) {
@@ -349,6 +352,7 @@ class HeapViewController {
         for (const component of this.componentIdToComponentMap.values()) {
             if (component.id === componentId) {
                 component.focus();
+                this.focusedComponent = component;
                 const data = this.componentIdToDataMap.get(componentId);
                 const selectIndex = (_a = (data && data.selectedIdx)) !== null && _a !== void 0 ? _a : -1;
                 this.setSelectedHeapObjectFromComponent(componentId, selectIndex);

package/dist/commands/heap/interactive/ui-components/ListComponent.js

@@ -145,6 +145,7 @@ class ListComponent {
     }
     focus() {
         this.element.focus();
+        this.element.setFront();
         this.element.style.border.fg = 'white';
         this.element.style.selected = {
             bg: 'grey',

package/dist/commands/helper/GenerateCLIDocCommand.js

@@ -132,11 +132,16 @@ class GenerateCLIDocCommand extends BaseCommand_1.default {
     }
     writeCommand(docFile, command, indent = '') {
         const name = command.getFullCommand();
-        const desc = core_1.utils.upperCaseFirstCharacter(command.getDescription());
+        const desc = core_1.utils.upperCaseFirstCharacter(command.getDescription().trim());
+        const cmdDoc = command.getDocumenation().trim();
         // write command title
         this.writeTextWithNewLine(docFile, `\n###${indent} memlab ${name}\n`);
         // write description
         this.writeTextWithNewLine(docFile, `${desc}\n`);
+        // write detailed command documentation
+        if (cmdDoc.length > 0) {
+            this.writeTextWithNewLine(docFile, `${cmdDoc}\n`);
+        }
         // get example
         const examples = command.getExamples();
         let example = '';

package/dist/commands/helper/HelperCommand.js

@@ -48,10 +48,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const chalk_1 = __importDefault(require("chalk"));
 const string_width_1 = __importDefault(require("string-width"));
 const core_1 = require("@memlab/core");
+const heap_analysis_1 = require("@memlab/heap-analysis");
 const CommandOrder_1 = __importDefault(require("./lib/CommandOrder"));
 const BaseCommand_1 = __importStar(require("../../BaseCommand"));
 const UniversalOptions_1 = __importDefault(require("../../options/lib/UniversalOptions"));
-const heap_analysis_1 = require("@memlab/heap-analysis");
+const CLIUtils_1 = require("../../lib/CLIUtils");
 class HelperCommand extends BaseCommand_1.default {
     constructor() {
         super(...arguments);
@@ -137,7 +138,7 @@ class HelperCommand extends BaseCommand_1.default {
         if (options.length === 0) {
             return '';
         }
-        const width = Math.min(70, process.stdout.columns);
+        const width = Math.min(CLIUtils_1.READABLE_CMD_FLAG_WIDTH, process.stdout.columns);
         let summary = '';
         let curLine = chalk_1.default.bold(`${indent}Options:`);
         for (const option of options) {
@@ -177,25 +178,21 @@ class HelperCommand extends BaseCommand_1.default {
     }
     formatOptionText(optionText, indent, headerLength) {
         const header = chalk_1.default.green(optionText.header);
-        const prefix = core_1.utils.repeat(' ', headerLength - optionText.header.length);
+        const prefix = (0, CLIUtils_1.getBlankSpaceString)(headerLength - optionText.header.length);
         const headerString = `${indent}${prefix}${header} `;
         const headerStringWidth = (0, string_width_1.default)(headerString);
-        const maxWidth = Math.min(process.stdout.columns, 150);
-        const descMaxWidth = maxWidth - headerStringWidth;
-        let descString = optionText.desc.substring(0, descMaxWidth);
-        let descStringRemain = optionText.desc.substring(descMaxWidth);
-        while (descStringRemain.length > 0) {
-            descString += '\n';
-            descString += core_1.utils.repeat(' ', headerStringWidth);
-            descString += descStringRemain.substring(0, descMaxWidth);
-            descStringRemain = descStringRemain.substring(descMaxWidth);
-        }
-        return `${headerString}${descString}`;
+        const maxWidth = Math.min(process.stdout.columns, CLIUtils_1.READABLE_TEXT_WIDTH);
+        const descString = (0, CLIUtils_1.alignTextInBlock)(optionText.desc, {
+            leftIndent: headerStringWidth,
+            lineLength: maxWidth,
+        });
+        return `${headerString}${descString.substring(headerStringWidth)}`;
     }
     printCommand(command, extraIndent = '', printOptions = false) {
         const indent = '  ' + extraIndent;
         const name = command.getFullCommand();
-        const desc = core_1.utils.upperCaseFirstCharacter(command.getDescription());
+        const desc = core_1.utils.upperCaseFirstCharacter(command.getDescription().trim());
+        const cmdDoc = command.getDocumenation().trim();
         // get example
         const examples = command.getExamples();
         let example = '';
@@ -205,6 +202,12 @@ class HelperCommand extends BaseCommand_1.default {
         const cmd = chalk_1.default.green(`memlab ${name}${example}`);
         let msg = `${indent}${cmd}`;
         msg += `\n${indent}${desc}`;
+        if (cmdDoc.length > 0) {
+            const cmdDocBlock = (0, CLIUtils_1.alignTextInBlock)(cmdDoc, {
+                leftIndent: indent.length + 2,
+            });
+            msg += `\n\n${chalk_1.default.grey(cmdDocBlock)}`;
+        }
         core_1.info.topLevel(msg);
         // print options info
         if (printOptions) {

package/dist/lib/CLIUtils.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @format
+ * @oncall web_perf_infra
+ */
+import type { ParsedArgs } from 'minimist';
+import type { AnyRecord } from '@memlab/core';
+export declare type BlockTextOption = {
+    leftIndent?: number;
+    lineLength?: number;
+};
+export declare const READABLE_CMD_FLAG_WIDTH = 70;
+export declare const READABLE_TEXT_WIDTH = 150;
+export declare function filterAndGetUndefinedArgs(cliArgs: ParsedArgs): AnyRecord;
+export declare function argsToString(args: AnyRecord): string;
+export declare function getBlankSpaceString(length: number): string;
+export declare function alignTextInBlock(text: string, options: BlockTextOption): string;
+//# sourceMappingURL=CLIUtils.d.ts.map

package/dist/lib/CLIUtils.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alignTextInBlock = exports.getBlankSpaceString = exports.argsToString = exports.filterAndGetUndefinedArgs = exports.READABLE_TEXT_WIDTH = exports.READABLE_CMD_FLAG_WIDTH = void 0;
+const string_width_1 = __importDefault(require("string-width"));
+const core_1 = require("@memlab/core");
+const OptionConstant_1 = __importDefault(require("../options/lib/OptionConstant"));
+const breakableSymbolOnRight = new Set([
+    ' ',
+    '\t',
+    ',',
+    '.',
+    ':',
+    ';',
+    '!',
+    '?',
+    ')',
+    ']',
+    '}',
+    '>',
+]);
+const breakableSymbolOnLeft = new Set([' ', '\t', '(', '[', '{', '<']);
+exports.READABLE_CMD_FLAG_WIDTH = 70;
+exports.READABLE_TEXT_WIDTH = 150;
+function filterAndGetUndefinedArgs(cliArgs) {
+    const ret = Object.create(null);
+    const memlabFBOptionNames = new Set(Object.values(Object.assign({}, OptionConstant_1.default.optionNames)));
+    for (const optionName of Object.keys(cliArgs)) {
+        if (optionName === '_') {
+            continue;
+        }
+        if (memlabFBOptionNames.has(optionName)) {
+            continue;
+        }
+        ret[optionName] = cliArgs[optionName];
+    }
+    return ret;
+}
+exports.filterAndGetUndefinedArgs = filterAndGetUndefinedArgs;
+function argsToString(args) {
+    let ret = '';
+    for (const optionName of Object.keys(args)) {
+        if (optionName === '_') {
+            continue;
+        }
+        const value = args[optionName];
+        if (value === true) {
+            ret += `--${optionName} `;
+        }
+        else if (Array.isArray(value)) {
+            value.forEach(v => {
+                ret += `--${optionName}=${v} `;
+            });
+        }
+        else {
+            ret += `--${optionName}=${value} `;
+        }
+    }
+    return ret.trim();
+}
+exports.argsToString = argsToString;
+function getBlankSpaceString(length) {
+    let ret = '';
+    for (let i = 0; i < length; ++i) {
+        ret += ' ';
+    }
+    return ret;
+}
+exports.getBlankSpaceString = getBlankSpaceString;
+function alignTextInBlock(text, options) {
+    var _a, _b;
+    const indent = (_a = options.leftIndent) !== null && _a !== void 0 ? _a : 0;
+    const maxLineWidth = Math.min(exports.READABLE_TEXT_WIDTH, (_b = options.lineLength) !== null && _b !== void 0 ? _b : process.stdout.columns);
+    if (indent < 0 || maxLineWidth <= 0 || indent >= maxLineWidth) {
+        throw core_1.utils.haltOrThrow('invalid indent or maximum line width');
+    }
+    const indentString = getBlankSpaceString(indent);
+    const inputLines = text.split('\n');
+    const outputLines = [];
+    while (inputLines.length > 0) {
+        const line = inputLines.shift();
+        // if the current line can fit in cmd row
+        if ((0, string_width_1.default)(indentString + line) <= maxLineWidth) {
+            outputLines.push(indentString + line);
+            continue;
+        }
+        // otherwise split the current line
+        const intendedSplitPoint = maxLineWidth - indent;
+        const splitLines = splitIntoReadableSubstrings(line, intendedSplitPoint);
+        const [firstLine, restLine] = splitLines;
+        outputLines.push(indentString + firstLine);
+        inputLines.unshift(restLine);
+    }
+    return outputLines.join('\n');
+}
+exports.alignTextInBlock = alignTextInBlock;
+function splitIntoReadableSubstrings(text, intendedSplitPoint) {
+    if (intendedSplitPoint >= text.length) {
+        return [text];
+    }
+    let splitPoint = intendedSplitPoint;
+    while (splitPoint > 0) {
+        const ch = text[splitPoint];
+        if (breakableSymbolOnLeft.has(ch)) {
+            break;
+        }
+        if (splitPoint - 1 > 0 &&
+            breakableSymbolOnRight.has(text[splitPoint - 1])) {
+            break;
+        }
+        --splitPoint;
+    }
+    if (splitPoint <= 0) {
+        splitPoint = intendedSplitPoint;
+    }
+    // if the second line starts with a ' ',
+    // skip the empty space
+    const firstLine = text.substring(0, splitPoint);
+    let secondLine = text.substring(splitPoint);
+    if (secondLine.startsWith(' ')) {
+        secondLine = secondLine.substring(1);
+    }
+    if (secondLine.length === 0) {
+        return [firstLine];
+    }
+    return [firstLine, secondLine];
+}

package/dist/options/MLClusteringOption.d.ts

@@ -13,6 +13,7 @@ import { BaseOption } from '@memlab/core';
 export default class MLClusteringOption extends BaseOption {
     getOptionName(): string;
     getDescription(): string;
+    static hasOptionSet(args: ParsedArgs): boolean;
     parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
 }
 //# sourceMappingURL=MLClusteringOption.d.ts.map

package/dist/options/MLClusteringOption.js

@@ -30,6 +30,10 @@ class MLClusteringOption extends core_1.BaseOption {
     getDescription() {
         return 'use machine learning algorithms for clustering leak traces (by default, traces are clustered by heuristics)';
     }
+    static hasOptionSet(args) {
+        const name = OptionConstant_1.default.optionNames.ML_CLUSTERING;
+        return args[name] != null;
+    }
     parse(config, args) {
         return __awaiter(this, void 0, void 0, function* () {
             const name = this.getOptionName();

package/dist/options/NumberOfRunsOption.d.ts

@@ -8,13 +8,15 @@
  * @oncall web_perf_infra
  */
 import type { ParsedArgs } from 'minimist';
-import type { AnyRecord, MemLabConfig } from '@memlab/core';
+import type { AnyRecord, MemLabConfig, Optional } from '@memlab/core';
 import { BaseOption } from '@memlab/core';
 export default class NumberOfRunsOption extends BaseOption {
-    static DEFAULT_NUM_RUNS: number;
+    private defaultRunNumber;
+    constructor(runNumber?: number);
     getOptionName(): string;
     getDescription(): string;
     getExampleValues(): string[];
+    static getParsedOption(configFromOptions: Optional<AnyRecord>): number;
     parse(config: MemLabConfig, args: ParsedArgs): Promise<AnyRecord>;
 }
 //# sourceMappingURL=NumberOfRunsOption.d.ts.map

package/dist/options/NumberOfRunsOption.js

@@ -23,7 +23,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@memlab/core");
 const OptionConstant_1 = __importDefault(require("./lib/OptionConstant"));
+const DEFAULT_NUM_RUNS = 10;
 class NumberOfRunsOption extends core_1.BaseOption {
+    constructor(runNumber = DEFAULT_NUM_RUNS) {
+        super();
+        this.defaultRunNumber = DEFAULT_NUM_RUNS;
+        this.defaultRunNumber = runNumber;
+    }
     getOptionName() {
         return OptionConstant_1.default.optionNames.RUN_NUM;
     }
@@ -33,16 +39,18 @@ class NumberOfRunsOption extends core_1.BaseOption {
     getExampleValues() {
         return ['5'];
     }
+    static getParsedOption(configFromOptions) {
+        const { numOfRuns } = configFromOptions !== null && configFromOptions !== void 0 ? configFromOptions : {};
+        const n = parseInt(`${numOfRuns}`, 10);
+        return isNaN(n) ? DEFAULT_NUM_RUNS : n;
+    }
     parse(config, args) {
         return __awaiter(this, void 0, void 0, function* () {
             const ret = Object.create(null);
             const name = this.getOptionName();
-            ret.numOfRuns = args[name]
-                ? args[name] | 0
-                : NumberOfRunsOption.DEFAULT_NUM_RUNS;
+            ret.numOfRuns = args[name] != null ? args[name] | 0 : this.defaultRunNumber;
             return ret;
         });
     }
 }
 exports.default = NumberOfRunsOption;
-NumberOfRunsOption.DEFAULT_NUM_RUNS = 10;

package/dist/options/experiment/SetControlWorkDirOption.d.ts

@@ -13,8 +13,9 @@ import { BaseOption } from '@memlab/core';
 export default class SetControlWorkDirOption extends BaseOption {
     getOptionName(): string;
     getDescription(): string;
+    protected extractAndCheckWorkDirs(args: ParsedArgs): string[];
     parse(config: MemLabConfig, args: ParsedArgs): Promise<{
-        controlWorkDir?: string;
+        controlWorkDirs?: string[];
     }>;
 }
 //# sourceMappingURL=SetControlWorkDirOption.d.ts.map

package/dist/options/experiment/SetControlWorkDirOption.js

@@ -21,6 +21,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
 const core_1 = require("@memlab/core");
 const OptionConstant_1 = __importDefault(require("../lib/OptionConstant"));
 class SetControlWorkDirOption extends core_1.BaseOption {
@@ -30,14 +31,32 @@ class SetControlWorkDirOption extends core_1.BaseOption {
     getDescription() {
         return 'set the working directory of the control run';
     }
+    extractAndCheckWorkDirs(args) {
+        let dirs = [];
+        const name = this.getOptionName();
+        const flagValue = args[name];
+        if (!flagValue) {
+            return dirs;
+        }
+        if (Array.isArray(flagValue)) {
+            dirs = flagValue;
+        }
+        else {
+            dirs = [flagValue];
+        }
+        for (const dir of dirs) {
+            if (fs_1.default.existsSync(dir)) {
+                core_1.fileManager.createDefaultVisitOrderMetaFile({
+                    workDir: dir,
+                });
+            }
+        }
+        return dirs;
+    }
     parse(config, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            const name = this.getOptionName();
-            const ret = {};
-            if (args[name]) {
-                ret.controlWorkDir = args[name];
-            }
-            return ret;
+            const dirs = this.extractAndCheckWorkDirs(args);
+            return { controlWorkDirs: dirs };
         });
     }
 }

package/dist/options/experiment/SetTreatmentWorkDirOption.js

@@ -21,6 +21,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
 const core_1 = require("@memlab/core");
 const OptionConstant_1 = __importDefault(require("../lib/OptionConstant"));
 class SetTreatmentWorkDirOption extends core_1.BaseOption {
@@ -36,6 +37,11 @@ class SetTreatmentWorkDirOption extends core_1.BaseOption {
             const ret = {};
             if (args[name]) {
                 ret.treatmentWorkDir = args[name];
+                if (fs_1.default.existsSync(ret.treatmentWorkDir)) {
+                    core_1.fileManager.createDefaultVisitOrderMetaFile({
+                        workDir: ret.treatmentWorkDir,
+                    });
+                }
             }
             return ret;
         });

package/dist/options/heap/TraceAllObjectsOption.js

@@ -23,6 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@memlab/core");
 const OptionConstant_1 = __importDefault(require("../lib/OptionConstant"));
+const OversizeThresholdOption_1 = __importDefault(require("./OversizeThresholdOption"));
 class TraceAllObjectsOption extends core_1.BaseOption {
     getOptionName() {
         return OptionConstant_1.default.optionNames.TRACE_ALL_OBJECTS;
@@ -32,8 +33,13 @@ class TraceAllObjectsOption extends core_1.BaseOption {
     }
     parse(config, args) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (args[this.getOptionName()]) {
-                config.oversizeObjectAsLeak = true;
+            if (!args[this.getOptionName()]) {
+                return;
+            }
+            config.oversizeObjectAsLeak = true;
+            const overSizeOptionName = new OversizeThresholdOption_1.default().getOptionName();
+            // over size option will set the oversize threshold
+            if (!args[overSizeOptionName]) {
                 config.oversizeThreshold = 0;
             }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/cli",
-  "version": "1.0.23",
+  "version": "1.0.24",
   "license": "MIT",
   "description": "command line interface for memlab",
   "author": "Liang Gong <lgong@fb.com>",