@memlab/cli 1.0.5 → 1.0.8

package/bin/{memlab → memlab.js}

@@ -10,5 +10,12 @@
  * @format
  */
 
-var cli = require("@memlab/cli");
-cli.run();
+// eslint-disable-next-line no-var
+var cli = require('../dist/index');
+
+// register the `@memlab/cli` package info
+// so that `memlab version` get use the info
+// eslint-disable-next-line fb-www/promise-termination
+cli.registerPackage().then(() => {
+  cli.run();
+});

package/dist/CommandLoader.d.ts

@@ -9,14 +9,15 @@
  */
 import BaseCommand from './BaseCommand';
 export default class CommandLoader {
-    private isLoaded;
-    private OSSModules;
-    private modules;
-    private modulePaths;
+    protected isLoaded: boolean;
+    protected OSSModules: Map<string, BaseCommand>;
+    protected modules: Map<string, BaseCommand>;
+    protected modulePaths: Map<string, string>;
     getModules(): Map<string, BaseCommand>;
     getModulePaths(): Map<string, string>;
     registerCommands(): void;
-    private registerCommandsFromDir;
-    private postRegistration;
+    protected shouldRegisterCommand(command: BaseCommand): boolean;
+    protected registerCommandsFromDir(modulesDir: string): void;
+    protected postRegistration(): void;
 }
 //# sourceMappingURL=CommandLoader.d.ts.map

package/dist/CommandLoader.js

@@ -41,6 +41,10 @@ class CommandLoader {
         this.registerCommandsFromDir(modulesDir);
         this.postRegistration();
     }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    shouldRegisterCommand(command) {
+        return true;
+    }
     registerCommandsFromDir(modulesDir) {
         const moduleFiles = fs_1.default.readdirSync(modulesDir);
         for (const moduleFile of moduleFiles) {
@@ -61,6 +65,9 @@ class CommandLoader {
             if (!(moduleInstance instanceof BaseCommand_1.default)) {
                 core_1.utils.haltOrThrow('loading a command that does not extend BaseCommand');
             }
+            if (!this.shouldRegisterCommand(moduleInstance)) {
+                continue;
+            }
             const commandName = moduleInstance.getCommandName();
             const loadingOssCommand = !core_1.fileManager.isWithinInternalDirectory(modulePath);
             // reigster OSS commands

package/dist/Dispatcher.d.ts

@@ -10,16 +10,21 @@
 import type { ParsedArgs } from 'minimist';
 import type { AnyRecord, MemLabConfig } from '@memlab/core';
 import BaseCommand from './BaseCommand';
+import CommandLoader from './CommandLoader';
 declare type RunCommandOptions = {
     isPrerequisite?: boolean;
     commandIndex?: number;
     configFromOptions: AnyRecord;
 };
-declare class CommandDispatcher {
+declare type CommandDispatcherOptions = {
+    commandLoader?: CommandLoader;
+};
+export declare class CommandDispatcher {
     private modules;
     private executedCommands;
     private executingCommandStack;
-    constructor();
+    constructor(options?: CommandDispatcherOptions);
+    protected resetData(): void;
     dispatch(args: ParsedArgs): Promise<void>;
     parseOptions(command: BaseCommand, config: MemLabConfig, args: ParsedArgs): Promise<AnyRecord>;
     private runCommand;

package/dist/Dispatcher.js

@@ -21,21 +21,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandDispatcher = void 0;
 const core_1 = require("@memlab/core");
 const HelperCommand_1 = __importDefault(require("./commands/helper/HelperCommand"));
 const UniversalOptions_1 = __importDefault(require("./options/lib/UniversalOptions"));
 const CommandLoader_1 = __importDefault(require("./CommandLoader"));
 const helperCommand = new HelperCommand_1.default();
 class CommandDispatcher {
-    constructor() {
-        this.executedCommands = new Set();
-        this.executingCommandStack = [];
+    constructor(options = {}) {
+        var _a;
+        this.resetData();
         // auto load all command modules
-        const commandLoader = new CommandLoader_1.default();
+        const commandLoader = (_a = options.commandLoader) !== null && _a !== void 0 ? _a : new CommandLoader_1.default();
         this.modules = commandLoader.getModules();
     }
+    resetData() {
+        this.executedCommands = new Set();
+        this.executingCommandStack = [];
+    }
     dispatch(args) {
         return __awaiter(this, void 0, void 0, function* () {
+            this.resetData();
             // triggered by `memlab` (without specific command)
             if (!args._ || !(args._.length >= 1)) {
                 core_1.info.error('\n  command argument missing');
@@ -121,7 +127,7 @@ class CommandDispatcher {
             const subCommands = command.getSubCommands();
             for (const subCommand of subCommands) {
                 if (subCommand.getCommandName() === args._[subCommandIndex]) {
-                    this.runCommand(subCommand, args, runCmdOpt);
+                    yield this.runCommand(subCommand, args, runCmdOpt);
                     return;
                 }
             }
@@ -140,4 +146,5 @@ class CommandDispatcher {
         });
     }
 }
+exports.CommandDispatcher = CommandDispatcher;
 exports.default = new CommandDispatcher();

package/dist/commands/GetVersionCommand.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { CLIOptions } from '@memlab/core';
+import BaseCommand from '../BaseCommand';
+export default class GetVersionCommand extends BaseCommand {
+    getCommandName(): string;
+    getDescription(): string;
+    private loadDepencyPackageInfo;
+    run(options: CLIOptions): Promise<void>;
+}
+//# sourceMappingURL=GetVersionCommand.d.ts.map

package/dist/commands/GetVersionCommand.js

@@ -0,0 +1,69 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const BaseCommand_1 = __importDefault(require("../BaseCommand"));
+const core_1 = require("@memlab/core");
+const api_1 = require("@memlab/api");
+const core_2 = require("@memlab/core");
+const heap_analysis_1 = require("@memlab/heap-analysis");
+const e2e_1 = require("@memlab/e2e");
+class GetVersionCommand extends BaseCommand_1.default {
+    getCommandName() {
+        return 'version';
+    }
+    getDescription() {
+        return 'Show the versions of all memlab packages installed';
+    }
+    loadDepencyPackageInfo() {
+        return __awaiter(this, void 0, void 0, function* () {
+            // require all sub-packages to register package information
+            // memlab and cli packages already registered in the bin file
+            // the following sub-packages are registered here lazily to
+            // avoid too many file operations
+            return Promise.all([
+                (0, api_1.registerPackage)(),
+                (0, core_2.registerPackage)(),
+                (0, heap_analysis_1.registerPackage)(),
+                (0, e2e_1.registerPackage)(),
+            ]);
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    run(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loadDepencyPackageInfo();
+            const packages = [...core_1.config.packageInfo].sort((p1, p2) => p1.name < p2.name ? 1 : -1);
+            core_1.info.topLevel('');
+            for (const pkg of packages) {
+                const version = chalk_1.default.grey(`@${pkg.version}`);
+                core_1.info.topLevel(` ${pkg.name}${version}`);
+                if (core_1.config.verbose && pkg.packageLocation) {
+                    core_1.info.lowLevel(`  ${pkg.packageLocation}`);
+                }
+            }
+            core_1.info.topLevel('');
+        });
+    }
+}
+exports.default = GetVersionCommand;

package/dist/commands/heap/CheckLeakCommand.js

@@ -58,6 +58,9 @@ const LogTraceAsClusterOption_1 = __importDefault(require("../../options/heap/Lo
 const CleanLoggerDataCommand_1 = __importDefault(require("../CleanLoggerDataCommand"));
 const LeakFilterFileOption_1 = __importDefault(require("../../options/heap/leak-filter/LeakFilterFileOption"));
 const LeakClusterSizeThresholdOption_1 = __importDefault(require("../../options/heap/LeakClusterSizeThresholdOption"));
+const MLClusteringOption_1 = __importDefault(require("../../options/MLClusteringOption"));
+const MLClusteringLinkageMaxDistanceOption_1 = __importDefault(require("../../options/MLClusteringLinkageMaxDistanceOption"));
+const MLClusteringMaxDFOption_1 = __importDefault(require("../../options/MLClusteringMaxDFOption"));
 class CheckLeakCommand extends BaseCommand_1.default {
     getCommandName() {
         return 'find-leaks';
@@ -83,6 +86,9 @@ class CheckLeakCommand extends BaseCommand_1.default {
             new LeakClusterSizeThresholdOption_1.default(),
             new TraceAllObjectsOption_1.default(),
             new LogTraceAsClusterOption_1.default(),
+            new MLClusteringOption_1.default(),
+            new MLClusteringLinkageMaxDistanceOption_1.default(),
+            new MLClusteringMaxDFOption_1.default(),
         ];
     }
     // eslint-disable-next-line @typescript-eslint/no-unused-vars

package/dist/commands/heap/interactive/InteractiveCommandLoader.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import BaseCommand from '../../../BaseCommand';
+import CommandLoader from '../../../CommandLoader';
+export default class InteractiveCommandLoader extends CommandLoader {
+    protected shouldRegisterCommand(command: BaseCommand): boolean;
+    protected postRegistration(): void;
+}
+//# sourceMappingURL=InteractiveCommandLoader.d.ts.map

package/dist/commands/heap/interactive/InteractiveCommandLoader.js

@@ -0,0 +1,33 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CommandLoader_1 = __importDefault(require("../../../CommandLoader"));
+const HelperCommand_1 = __importDefault(require("../../helper/HelperCommand"));
+const GetRetainerTraceCommand_1 = __importDefault(require("../GetRetainerTraceCommand"));
+const HeapAnalysisCommand_1 = __importDefault(require("../HeapAnalysisCommand"));
+const commandToInclude = new Set([
+    HeapAnalysisCommand_1.default,
+    GetRetainerTraceCommand_1.default,
+    HelperCommand_1.default,
+]);
+class InteractiveCommandLoader extends CommandLoader_1.default {
+    shouldRegisterCommand(command) {
+        const constructor = command.constructor;
+        return commandToInclude.has(constructor);
+    }
+    postRegistration() {
+        // do nothing
+    }
+}
+exports.default = InteractiveCommandLoader;

package/dist/commands/heap/interactive/InteractiveHeapCommand.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import { CLIOptions } from '@memlab/core';
+import BaseCommand, { CommandCategory } from '../../../BaseCommand';
+import { BaseOption } from '@memlab/core';
+export default class InteractiveHeapCommand extends BaseCommand {
+    getCommandName(): string;
+    getDescription(): string;
+    getCategory(): CommandCategory;
+    getExamples(): string[];
+    getOptions(): BaseOption[];
+    private printPromptInfo;
+    private startInteractiveCLI;
+    run(options: CLIOptions): Promise<void>;
+}
+//# sourceMappingURL=InteractiveHeapCommand.d.ts.map

package/dist/commands/heap/interactive/InteractiveHeapCommand.js

@@ -0,0 +1,127 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+const chalk_1 = __importDefault(require("chalk"));
+const readline_1 = __importDefault(require("readline"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const minimist_1 = __importDefault(require("minimist"));
+const BaseCommand_1 = __importStar(require("../../../BaseCommand"));
+const core_2 = require("@memlab/core");
+const SnapshotFileOption_1 = __importDefault(require("../../../options/heap/SnapshotFileOption"));
+const JSEngineOption_1 = __importDefault(require("../../../options/heap/JSEngineOption"));
+const core_3 = require("@memlab/core");
+const heap_analysis_1 = require("@memlab/heap-analysis");
+const Dispatcher_1 = require("../../../Dispatcher");
+const InteractiveCommandLoader_1 = __importDefault(require("./InteractiveCommandLoader"));
+class InteractiveHeapCommand extends BaseCommand_1.default {
+    getCommandName() {
+        return 'heap';
+    }
+    getDescription() {
+        return 'interactive command to explore a single heap snapshot';
+    }
+    getCategory() {
+        return BaseCommand_1.CommandCategory.COMMON;
+    }
+    getExamples() {
+        return ['--snapshot <HEAP_SNAPSHOT_FILE>'];
+    }
+    getOptions() {
+        return [new SnapshotFileOption_1.default(), new JSEngineOption_1.default()];
+    }
+    printPromptInfo() {
+        core_2.info.topLevel(`Heap Snapshot Loaded: ${chalk_1.default.grey(heap_analysis_1.heapConfig.currentHeapFile)}`);
+    }
+    startInteractiveCLI() {
+        const rl = readline_1.default.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            prompt: 'memlab > ',
+        });
+        // the interactive cli only supports a subset of memlab commands
+        const dispatcher = new Dispatcher_1.CommandDispatcher({
+            commandLoader: new InteractiveCommandLoader_1.default(),
+        });
+        // do not halt execution when running the interactive command
+        core_2.config.errorHandling = core_1.ErrorHandling.Throw;
+        // start the interactive prompt
+        this.printPromptInfo();
+        rl.prompt();
+        // start interpreting interactive commands
+        rl.on('line', (line) => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // "memlab <command>" -> "<command>"
+                const command = line.trim().startsWith('memlab ')
+                    ? line.substring('memlab '.length)
+                    : line;
+                const args = command.match(/("[^"]+")|('[^']+')|(\S+)/g);
+                const parsedArgs = (0, minimist_1.default)(args);
+                yield dispatcher.dispatch(parsedArgs);
+            }
+            catch (ex) {
+                const error = core_2.utils.getError(ex);
+                core_2.info.topLevel(error.message);
+            }
+            core_2.info.topLevel('');
+            this.printPromptInfo();
+            rl.prompt();
+        }));
+    }
+    run(options) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const workDir = (_a = options.configFromOptions) === null || _a === void 0 ? void 0 : _a.workDir;
+            const reportOutDir = core_3.fileManager.getReportOutDir({ workDir });
+            fs_extra_1.default.emptyDirSync(reportOutDir);
+            // load single heap snapshot
+            heap_analysis_1.heapConfig.isCliInteractiveMode = true;
+            yield (0, heap_analysis_1.loadHeapSnapshot)({ args: options.cliArgs });
+            this.startInteractiveCLI();
+        });
+    }
+}
+exports.default = InteractiveHeapCommand;

package/dist/commands/helper/HelperCommand.js

@@ -51,6 +51,7 @@ const core_1 = require("@memlab/core");
 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");
 class HelperCommand extends BaseCommand_1.default {
     constructor() {
         super(...arguments);
@@ -81,7 +82,11 @@ class HelperCommand extends BaseCommand_1.default {
     printCommandCategories(options) {
         for (const category in BaseCommand_1.CommandCategory) {
             const item = CommandOrder_1.default.find(item => item.category === category);
-            const commandsToPrintFirst = item ? item.commands : [];
+            const commandsToPrintFirst = heap_analysis_1.heapConfig.isCliInteractiveMode
+                ? []
+                : item
+                    ? item.commands
+                    : [];
             this.printCategory(category, commandsToPrintFirst, options);
         }
     }
@@ -93,13 +98,13 @@ class HelperCommand extends BaseCommand_1.default {
         core_1.info.topLevel('');
     }
     printCategory(category, commandsToPrintFirst, options) {
-        this.printCategoryHeader(category, options);
+        const commandsToPrint = [];
         for (const command of commandsToPrintFirst) {
             const name = command.getCommandName();
             if (this.printedCommand.has(name)) {
                 continue;
             }
-            this.printCommand(command, options.indent);
+            commandsToPrint.push(command);
             this.printedCommand.add(name);
         }
         // print other commands in this category
@@ -115,9 +120,16 @@ class HelperCommand extends BaseCommand_1.default {
             if (this.printedCommand.has(name)) {
                 continue;
             }
-            this.printCommand(command, options.indent);
+            commandsToPrint.push(command);
             this.printedCommand.add(name);
         }
+        if (commandsToPrint.length === 0) {
+            return;
+        }
+        this.printCategoryHeader(category, options);
+        for (const command of commandsToPrint) {
+            this.printCommand(command, options.indent);
+        }
         core_1.info.topLevel('');
     }
     getCommandOptionsSummary(command, indent = '') {

package/dist/index.d.ts

@@ -7,5 +7,7 @@
  * @emails oncall+ws_labs
  * @format
  */
+/** @internal */
+export declare function registerPackage(): Promise<void>;
 export * from './runner';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -22,5 +22,27 @@ var __createBinding = (this && this.__createBinding) || (Object.create ? (functi
 var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPackage = void 0;
+const path_1 = __importDefault(require("path"));
+const core_1 = require("@memlab/core");
+/** @internal */
+function registerPackage() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return core_1.PackageInfoLoader.registerPackage(path_1.default.join(__dirname, '..'));
+    });
+}
+exports.registerPackage = registerPackage;
 __exportStar(require("./runner"), exports);

package/dist/options/MLClusteringLinkageMaxDistanceOption.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { ParsedArgs } from 'minimist';
+import { MemLabConfig } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export default class MLClusteringLinkageMaxDistanceOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=MLClusteringLinkageMaxDistanceOption.d.ts.map

package/dist/options/MLClusteringLinkageMaxDistanceOption.js

@@ -0,0 +1,47 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+const core_2 = require("@memlab/core");
+class MLClusteringLinkageMaxDistanceOption extends core_2.BaseOption {
+    getOptionName() {
+        return 'ml-linkage-max-dist';
+    }
+    getDescription() {
+        return 'set linkage max distance value for clustering. The value should be between [0, 1] inclusive.';
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (args['ml-linkage-max-dist']) {
+                const linkageMaxDist = args['ml-linkage-max-dist'];
+                const linkageMaxDistNum = parseFloat(linkageMaxDist);
+                if (!isNaN(linkageMaxDistNum) &&
+                    linkageMaxDistNum >= 0 &&
+                    linkageMaxDistNum <= 1) {
+                    config.mlClusteringLinkageMaxDistance = linkageMaxDistNum;
+                }
+                else {
+                    core_1.utils.haltOrThrow(`ml-linkage-max-dist is not number between [0, 1]. ml-linkage-max-dist=${linkageMaxDist}`);
+                }
+            }
+        });
+    }
+}
+exports.default = MLClusteringLinkageMaxDistanceOption;

package/dist/options/MLClusteringMaxDFOption.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { ParsedArgs } from 'minimist';
+import { MemLabConfig } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export default class MLClusteringMaxDFOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=MLClusteringMaxDFOption.d.ts.map

package/dist/options/MLClusteringMaxDFOption.js

@@ -0,0 +1,47 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+const core_2 = require("@memlab/core");
+class MLClusteringMaxDFOption extends core_2.BaseOption {
+    getOptionName() {
+        return 'ml-clustering-max-df';
+    }
+    getDescription() {
+        return 'set percentage based max document frequency for limiting the terms that appear too often';
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (args['ml-clustering-max-df']) {
+                const clusteringMaxDFStr = args['ml-clustering-max-df'];
+                const clusteringMaxDF = parseFloat(clusteringMaxDFStr);
+                if (!isNaN(clusteringMaxDF) &&
+                    clusteringMaxDF >= 0 &&
+                    clusteringMaxDF <= 1) {
+                    config.mlMaxDF = clusteringMaxDF;
+                }
+                else {
+                    core_1.utils.haltOrThrow(`ml-clustering-max-df is not number between [0, 1]. ml-clustering-max-df=${clusteringMaxDF}`);
+                }
+            }
+        });
+    }
+}
+exports.default = MLClusteringMaxDFOption;

package/dist/options/MLClusteringOption.d.ts

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+import type { ParsedArgs } from 'minimist';
+import type { MemLabConfig } from '@memlab/core';
+import { BaseOption } from '@memlab/core';
+export default class MLClusteringOption extends BaseOption {
+    getOptionName(): string;
+    getDescription(): string;
+    parse(config: MemLabConfig, args: ParsedArgs): Promise<void>;
+}
+//# sourceMappingURL=MLClusteringOption.d.ts.map

package/dist/options/MLClusteringOption.js

@@ -0,0 +1,37 @@
+"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.
+ *
+ * @emails oncall+ws_labs
+ * @format
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@memlab/core");
+class MLClusteringOption extends core_1.BaseOption {
+    getOptionName() {
+        return 'ml-clustering';
+    }
+    getDescription() {
+        return 'use machine learning algorithms for clustering leak traces (by default, traces are clustered by heuristics)';
+    }
+    parse(config, args) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (args['ml-clustering']) {
+                config.isMLClustering = true;
+            }
+        });
+    }
+}
+exports.default = MLClusteringOption;

package/dist/options/heap/leak-filter/examples/large-object-as-leak.example.js

@@ -5,7 +5,6 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+ws_labs
  * @format
  * @oncall ws_labs
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@memlab/cli",
-  "version": "1.0.5",
+  "version": "1.0.8",
   "license": "MIT",
   "description": "command line interface for memlab",
   "author": "Liang Gong <lgong@fb.com>",
@@ -18,16 +18,16 @@
     "dist"
   ],
   "bin": {
-    "memlab": "bin/memlab"
+    "memlab": "bin/memlab.js"
   },
   "publishConfig": {
     "access": "public"
   },
   "dependencies": {
-    "@memlab/api": "^1.0.0",
-    "@memlab/core": "^1.0.0",
-    "@memlab/e2e": "^1.0.0",
-    "@memlab/heap-analysis": "^1.0.0",
+    "@memlab/api": "^1.0.6",
+    "@memlab/core": "^1.1.6",
+    "@memlab/e2e": "^1.0.7",
+    "@memlab/heap-analysis": "^1.0.5",
     "ansi": "^0.3.1",
     "babar": "^0.2.0",
     "chalk": "^4.0.0",