appmap 0.62.0 → 0.62.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a6320c85ad8807149cb904032ad4f9a316b7bcd9454985e0851601745dbca70
-  data.tar.gz: 18434ce1e06c9f3580c9d86bca8dc21966f7c728a20e8c0d782638af5ce93a28
+  metadata.gz: 8fecb692441e76ccbac48b93a85c46103a6f0a58768ab015ba4328828862b093
+  data.tar.gz: 5834edc795e1a0d5c627d69c9f7da81d8a4f1ab03eb51cde7b0c27c3ca686319
 SHA512:
-  metadata.gz: 6d3069df241f58d2d2e6497713ceeef3a5d97dc3ba5f11acd9eb25834ebc51bca21516717cb5ee941ac4ea4373ec17c5fe956f493705baa858a7ebac69b8c48e
-  data.tar.gz: 26dceefdd1aec688c9a7d17aa5ebfddf42310b9557905caccd3594d86b1b048fa72d0ca99004f4aae4f6262dd2f282f03c68d9e0377a70ca854c0713f424b652
+  metadata.gz: 8f22eb5fda7a94a2539d2810fdf871e33b71ffb1c07d93ce3f55620df175287537a4e5f66b1dec971063903c66b37fd12fefef7a83547667baaaa9437b41eb17
+  data.tar.gz: d56f26d16f8f2be4dcd3ec55bf2bc07f3c112a8c1e2015d4afef514c495952ef5691a9ace0c510b9961d113d87f4e811b0618c70ecd2191b04d5807c29c75e27

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# [0.62.1](https://github.com/applandinc/appmap-ruby/compare/v0.62.0...v0.62.1) (2021-08-06)
+
+* Ensure that `node_modules` is present in the release.
+
 # [0.62.0](https://github.com/applandinc/appmap-ruby/compare/v0.61.1...v0.62.0) (2021-07-21)
 
 

data/lib/appmap/version.rb

@@ -3,7 +3,7 @@
 module AppMap
   URL = 'https://github.com/applandinc/appmap-ruby'
 
-  VERSION = '0.62.0'
+  VERSION = '0.62.1'
 
   APPMAP_FORMAT_VERSION = '1.5.1'
 

data/node_modules/@appland/cli/CHANGELOG.md

@@ -0,0 +1,96 @@
+# [@appland/cli-v1.3.2](https://github.com/applandinc/appmap-js/compare/@appland/cli-v1.3.1...@appland/cli-v1.3.2) (2021-07-06)
+
+
+### Bug Fixes
+
+* Fix parent tree assignment in canonicalization ([fd54afa](https://github.com/applandinc/appmap-js/commit/fd54afa722166ce1ac022cbd649827ac2fa84b53))
+
+# [@appland/cli-v1.3.1](https://github.com/applandinc/appmap-js/compare/@appland/cli-v1.3.0...@appland/cli-v1.3.1) (2021-07-02)
+
+
+### Bug Fixes
+
+* Find all matching events in each AppMap ([de578c7](https://github.com/applandinc/appmap-js/commit/de578c73864e10c6b815ac460fb94b8a0b4eab92))
+
+# [@appland/cli-v1.3.0](https://github.com/applandinc/appmap-js/compare/@appland/cli-v1.2.0...@appland/cli-v1.3.0) (2021-07-02)
+
+
+### Bug Fixes
+
+* Don't emit trigrams with no caller and no callee ([65be7e5](https://github.com/applandinc/appmap-js/commit/65be7e5c03c3cd8a233c77bbb85c5ca54a563e07))
+* Only show progress bars in interactive mode ([6436a3b](https://github.com/applandinc/appmap-js/commit/6436a3b7bff79eafcfef554eb27dd581113bd9a0))
+* Refine JSON output of inspect command ([101e97e](https://github.com/applandinc/appmap-js/commit/101e97e3014ac41eda49b96b2f5a4a080bbf7f07))
+* Remove unused functions ([fe03064](https://github.com/applandinc/appmap-js/commit/fe030646ed6e85ecf3afc7a5f36948988e37e39e))
+* Update the AppMap index before the 'inspect' command runs ([1983813](https://github.com/applandinc/appmap-js/commit/19838133180ece16879af622bf3ccb576fc6de27))
+
+
+### Features
+
+* Add 'inventory' CLI command ([8175fb0](https://github.com/applandinc/appmap-js/commit/8175fb0727b40fdfc35720ead7362ae46ea2d877))
+* Add database_type to CodeObjectType.QUERY ([8787b2d](https://github.com/applandinc/appmap-js/commit/8787b2de0e05bce6753c90b3b6f08115c94e8cc7))
+* Add fingerprint strategies ([066bf9e](https://github.com/applandinc/appmap-js/commit/066bf9e1d2cf4767ca105d6f794daf8f82acaed5))
+* App.Land client ([775abb3](https://github.com/applandinc/appmap-js/commit/775abb3ad598031d9b95f20e7b12f88bd8d8da3b))
+* Fingerprint classes and packages ([7448804](https://github.com/applandinc/appmap-js/commit/74488040e804a6f57a19878980fa3ace25d6feb4))
+* Store the database_type in query classMap entries ([7a44af6](https://github.com/applandinc/appmap-js/commit/7a44af6504dc78574b3ba9eb5d1edb60d3124a44))
+
+# [@appland/cli-v1.2.0](https://github.com/applandinc/appmap-js/compare/@appland/cli-v1.1.0...@appland/cli-v1.2.0) (2021-06-29)
+
+
+### Features
+
+* Search by package and class ([0b14a27](https://github.com/applandinc/appmap-js/commit/0b14a2727f9aadbb43b69ac14d53258f45b20cf5))
+* Search for database:, http:, query: ([21df198](https://github.com/applandinc/appmap-js/commit/21df1983e47f3e77c2476dcf75fa8b8ee4ca5465))
+* Show progress bar while loading 'inspect' results ([2e3c410](https://github.com/applandinc/appmap-js/commit/2e3c410ea5d60b69b6f0ea5ef035f30f289088b8))
+
+# [@appland/cli-v1.1.0](https://github.com/applandinc/appmap-js/compare/@appland/cli-v1.0.4...@appland/cli-v1.1.0) (2021-06-16)
+
+
+### Bug Fixes
+
+* Remove 'example' because it adds so much noise ([17fb066](https://github.com/applandinc/appmap-js/commit/17fb066ba0e260911d4b204f6f6b4b310a13b7e1))
+
+
+### Features
+
+* Add 'swagger' command to the CLI ([3cb4380](https://github.com/applandinc/appmap-js/commit/3cb43808918dad92766b863326f0ff500cc235b2))
+* Add version file and created time to the AppMap index ([7496e3c](https://github.com/applandinc/appmap-js/commit/7496e3ceaf1dee3f96028d64246d7ea34b314386))
+* Find and print info about a named function ([544db5c](https://github.com/applandinc/appmap-js/commit/544db5ca402d9e3399326f28da7d3a43a606f5c4))
+* Search AppMaps for tables and routes ([e78d5b9](https://github.com/applandinc/appmap-js/commit/e78d5b91686818001a28ac6aee93ff388ec754e8))
+
+# [@appland/cli-v1.0.4](https://github.com/applandinc/appmap-js/compare/@appland/cli-v1.0.3...@appland/cli-v1.0.4) (2021-05-28)
+
+
+### Bug Fixes
+
+* Configure src/cli.js as the bin script for packages/cli ([0de396a](https://github.com/applandinc/appmap-js/commit/0de396a030c9451ee0f930a0f4a81281305ee312))
+* In dependency analysis, read the file mtime properly as the value of the file ([3700e96](https://github.com/applandinc/appmap-js/commit/3700e96caa322969d25332a613d6a6645d7d5ca5))
+* Remove dependency on yargs/helpers ([5e603d5](https://github.com/applandinc/appmap-js/commit/5e603d5b2c9e606ec82ae23ba2171f0327a7b658))
+
+# [@appland/cli-v1.0.3](https://github.com/applandinc/appmap-js/compare/@appland/cli-v1.0.2...@appland/cli-v1.0.3) (2021-05-18)
+
+
+### Bug Fixes
+
+* Update local dependencies ([f0d3281](https://github.com/applandinc/appmap-js/commit/f0d328161499999ee98fbb3aec2d438b3095bd0f))
+* Update yargs to v17.0 ([278f1da](https://github.com/applandinc/appmap-js/commit/278f1daab7bb6fc8371ac80bf210a1a6fce76f79))
+
+# [@appland/cli-v1.0.2](https://github.com/applandinc/appmap-js/compare/@appland/cli-v1.0.1...@appland/cli-v1.0.2) (2021-05-11)
+
+
+### Bug Fixes
+
+* Add publish config ([118c54f](https://github.com/applandinc/appmap-js/commit/118c54f3db08f19de39bca7d67abd36a0071a20e))
+
+# [@appland/cli-v1.0.1](https://github.com/applandinc/appmap-js/compare/@appland/cli-v1.0.0...@appland/cli-v1.0.1) (2021-05-11)
+
+
+### Bug Fixes
+
+* Flag package as public ([67e179c](https://github.com/applandinc/appmap-js/commit/67e179cd72ba247903764de25d8c86e0dd07bf9b))
+
+# @appland/cli-v1.0.0 (2021-05-11)
+
+
+### Features
+
+* Initial release ([#195](https://github.com/applandinc/appmap-js/issues/195)) ([c4776a0](https://github.com/applandinc/appmap-js/commit/c4776a0514c333746846b8ffca88465f8c2739ee))

data/node_modules/@appland/cli/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@appland/cli",
+  "version": "1.3.2",
+  "description": "",
+  "main": "src/cli.js",
+  "bin": {
+    "appmap-cli": "src/cli.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "lint": "eslint 'src/**/*.js' 'tests/**/*.js'",
+    "lint:fix": "eslint 'src/**/*.js' 'tests/**/*.js' --fix",
+    "pre-commit": "lint-staged",
+    "test": "jest"
+  },
+  "lint-staged": {
+    "*.{js,md,json}": [
+      "prettier --write"
+    ]
+  },
+  "author": "",
+  "license": "MIT",
+  "devDependencies": {
+    "eslint": "^7.25.0",
+    "eslint-config-airbnb-base": "^14.2.1",
+    "eslint-config-prettier": "^8.3.0",
+    "eslint-plugin-import": "^2.22.1",
+    "eslint-plugin-prettier": "^3.4.0",
+    "jest": "^26.6.3",
+    "lint-staged": "^10.5.4",
+    "prettier": "^2.2.1"
+  },
+  "dependencies": {
+    "@appland/models": "1.3.0",
+    "async": "^3.2.0",
+    "chokidar": "^3.5.1",
+    "cli-progress": "^3.9.0",
+    "console-table-printer": "^2.9.0",
+    "crypto-js": "^4.0.0",
+    "diff": "^5.0.0",
+    "fs-extra": "^9.1.0",
+    "glob": "^7.1.6",
+    "js-yaml": "^3.14.1",
+    "semver": "^7.3.5",
+    "yargs": "^17.0.1"
+  }
+}

data/node_modules/@appland/cli/src/appMapCatalog.js

@@ -0,0 +1,39 @@
+const fsp = require('fs').promises;
+const { baseName, listAppMapFiles } = require('./utils');
+
+/**
+ * appMapCatalog creates a lookup table of all the AppMap metadata in a directory (recursively).
+ *
+ * @param {string} directory path to the directory.
+ * @returns {Object<String,Metadata>} Map of AppMap names to metadata objects.
+ */
+async function appMapCatalog(directory) {
+  const appMapsByName = {};
+  const appMapFiles = [];
+  await listAppMapFiles(directory, (file) => {
+    appMapFiles.push(file);
+  });
+
+  await Promise.all(
+    // eslint-disable-next-line prefer-arrow-callback
+    appMapFiles.map(async (file) => {
+      const data = await fsp.readFile(`${baseName(file)}.metadata.json`);
+      const metadata = JSON.parse(data);
+      const entry = {
+        fileName: file,
+        metadata,
+      };
+      if (appMapsByName[metadata.name]) {
+        console.warn(
+          `AppMap name ${metadata.name} is not unique in the mapset`
+        );
+      } else {
+        appMapsByName[metadata.name] = entry;
+      }
+    })
+  );
+
+  return appMapsByName;
+}
+
+module.exports = appMapCatalog;

data/node_modules/@appland/cli/src/appland/getAppMap.js

@@ -0,0 +1,55 @@
+// @ts-check
+
+const { request: httpRequest } = require('http');
+const { request: httpsRequest } = require('https');
+const { baseURL, apiKey, exists } = require('./settings');
+
+/**
+ * Loads AppMap data from UUID.
+ *
+ * @param {string} uuid
+ * @returns {Promise<AppMapData>}
+ */
+const getAppMap = async (uuid) => {
+  if (!exists) {
+    throw new Error(`AppMap client is not configured`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const getScenarioURL = new URL([baseURL, 'api/appmaps', uuid].join('/'));
+    const requestFunction =
+      getScenarioURL.protocol === 'https:' ? httpsRequest : httpRequest;
+    const req = requestFunction(
+      getScenarioURL,
+      {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: 'application/json',
+        },
+      },
+      // eslint-disable-next-line consistent-return
+      (res) => {
+        if (res.statusCode >= 300) {
+          return reject(res.statusCode);
+        }
+        let data = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          resolve(JSON.parse(data));
+        });
+      }
+    );
+
+    req.on('error', (e) => {
+      reject(e);
+    });
+
+    // Write data to request body
+    req.end();
+  });
+};
+
+module.exports = getAppMap;

data/node_modules/@appland/cli/src/appland/listAppMaps.js

@@ -0,0 +1,58 @@
+// @ts-check
+
+const { request: httpRequest } = require('http');
+const { request: httpsRequest } = require('https');
+const { baseURL, apiKey, exists } = require('./settings');
+
+/** @typedef {import('../diff/types').AppMapListItem} AppMapListItem */
+
+/**
+ * Lists AppMaps in a mapset.
+ *
+ * @param {number} mapset
+ * @returns {Promise<AppMapListItem[]>}
+ */
+const listAppMaps = async (mapset) => {
+  if (!exists) {
+    throw new Error(`AppMap client is not configured`);
+  }
+
+  return new Promise((resolve, reject) => {
+    const listAppMapsURL = new URL([baseURL, 'api/appmaps'].join('/'));
+    listAppMapsURL.searchParams.append('mapsets[]', mapset.toString());
+    const requestFunction =
+      listAppMapsURL.protocol === 'https:' ? httpsRequest : httpRequest;
+    const req = requestFunction(
+      listAppMapsURL,
+      {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          Accept: 'application/json',
+        },
+      },
+      // eslint-disable-next-line consistent-return
+      (res) => {
+        if (res.statusCode >= 300) {
+          return reject(res.statusCode);
+        }
+        let data = '';
+        res.setEncoding('utf8');
+        res.on('data', (chunk) => {
+          data += chunk;
+        });
+        res.on('end', () => {
+          resolve(JSON.parse(data));
+        });
+      }
+    );
+
+    req.on('error', (e) => {
+      reject(e);
+    });
+
+    // Write data to request body
+    req.end();
+  });
+};
+
+module.exports = listAppMaps;

data/node_modules/@appland/cli/src/appland/settings.js

@@ -0,0 +1,62 @@
+// @ts-check
+
+const { join } = require('path');
+const { homedir } = require('os');
+const { statSync, readFileSync } = require('fs');
+const yaml = require('js-yaml');
+
+/**
+ * @param {string} msg
+ * @returns {{baseURL: string, apiKey: string, exists: boolean}}
+ */
+const failUsage = (msg) => {
+  console.warn(msg);
+  return { baseURL: null, apiKey: null, exists: false };
+};
+
+const { baseURL, apiKey, exists } =
+  /**
+   * @returns {{baseURL, apiKey}}
+   */
+  (() => {
+    const applandConfigFilePath = join(homedir(), '.appland');
+    const applandConfigStat = statSync(applandConfigFilePath);
+    if (!applandConfigStat.isFile()) {
+      return failUsage(
+        `AppMap Cloud config file ${applandConfigFilePath} does not exist`
+      );
+    }
+    const applandConfig = /** @type {object} */ (
+      yaml.load(readFileSync(applandConfigFilePath).toString())
+    );
+    const currentContext =
+      /** @type {string} */ applandConfig.current_context || 'default';
+    const contextConfig =
+      /** @type {import('./types').Context} */ applandConfig.contexts[
+        currentContext
+      ];
+    if (!contextConfig) {
+      return failUsage(
+        `No context configuration '${currentContext}' in AppMap Cloud config file ${applandConfigFilePath}`
+      );
+    }
+    const { url: configURL, api_key: configApiKey } = contextConfig;
+    if (!configURL) {
+      return failUsage(
+        `No 'url' in context configuration '${currentContext}' in AppMap Cloud config file ${applandConfigFilePath}`
+      );
+    }
+    if (!configApiKey) {
+      return failUsage(
+        `No 'api_key' in context configuration '${currentContext}' in AppMap Cloud config file ${applandConfigFilePath}`
+      );
+    }
+
+    return { baseURL: configURL, apiKey: configApiKey, exists: true };
+  })();
+
+module.exports = {
+  baseURL,
+  apiKey,
+  exists,
+};

data/node_modules/@appland/cli/src/appland/types.d.ts

@@ -0,0 +1,16 @@
+interface AppMapMetadata {
+  name: string;
+  fingerprints: Fingerprint[];
+}
+
+interface AppMapListItem {
+  scenario_uuid: string;
+  metadata: AppMapMetadata;
+}
+
+interface AppMapData {
+  version: string;
+  metadata: object;
+  classMap: object[];
+  events: object[];
+}

data/node_modules/@appland/cli/src/cli.js

@@ -0,0 +1,576 @@
+#! /usr/bin/env node
+/* eslint-disable no-use-before-define */
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-underscore-dangle */
+/* eslint-disable prefer-arrow-callback */
+/* eslint-disable func-names */
+/* eslint-disable max-classes-per-file */
+
+const yargs = require('yargs');
+const { diffLines } = require('diff');
+const yaml = require('js-yaml');
+const { promises: fsp, readFileSync } = require('fs');
+const { queue } = require('async');
+const process = require('process');
+const readline = require('readline');
+const { join } = require('path');
+const cliProgress = require('cli-progress');
+const { algorithms, canonicalize } = require('./fingerprint');
+const { verbose, loadAppMap } = require('./utils');
+const appMapCatalog = require('./appMapCatalog');
+const FingerprintDirectoryCommand = require('./fingerprint/fingerprintDirectoryCommand');
+const FingerprintWatchCommand = require('./fingerprint/fingerprintWatchCommand');
+const Depends = require('./depends');
+const FindCodeObjects = require('./search/findCodeObjects');
+const FindEvents = require('./search/findEvents');
+const FunctionStats = require('./functionStats');
+const Inspect = require('./inspect');
+const SwaggerCommand = require('./swagger/command');
+const InventoryCommand = require('./inventoryCommand');
+
+class DiffCommand {
+  baseDir(dir) {
+    this.baseDir = dir;
+    return this;
+  }
+
+  workingDir(dir) {
+    this.workingDir = dir;
+    return this;
+  }
+
+  /**
+   * Limits the diff computation to a specific AppMaps.
+   *
+   * @param {string[]} names
+   */
+  setAppMapNames(names) {
+    this.appMapNames = new Set(names);
+    return this;
+  }
+
+  /**
+   * Gets the names of all AppMaps which are added in the working set.
+   */
+  async added() {
+    await this._loadCatalogs();
+
+    return [...this.workingAppMapNames].filter(
+      (x) => !this.baseAppMapNames.has(x)
+    );
+  }
+
+  /**
+   * Gets the names of all AppMaps which are present in the base set but not present
+   * in the working set.
+   */
+  async removed() {
+    await this._loadCatalogs();
+
+    return [...this.baseAppMapNames].filter(
+      (x) => !this.workingAppMapNames.has(x)
+    );
+  }
+
+  /**
+   * Gets the names of all AppMaps which have present in both sets, but whose fingerprints
+   * have changed.
+   *
+   * @param {string} algorithmName Name of the canonicalization algorithm to use for the
+   * comparison.
+   */
+  async changed(algorithmName) {
+    await this._loadCatalogs();
+
+    const result = [];
+    Object.keys(this.workingCatalog)
+      .filter((name) => this.baseCatalog[name])
+      .filter(this._includesAppMap.bind(this))
+      .forEach((name) => {
+        const base = this.baseCatalog[name];
+        const working = this.workingCatalog[name];
+        if (!base.metadata.fingerprints || !working.metadata.fingerprints) {
+          console.warn(`No metadata.fingerprints found on AppMap ${name}`);
+          return;
+        }
+
+        const baseFingerprint = base.metadata.fingerprints.find(
+          (fingerprint) =>
+            fingerprint.canonicalization_algorithm === algorithmName
+        );
+        const workingFingerprint = working.metadata.fingerprints.find(
+          (fingerprint) =>
+            fingerprint.canonicalization_algorithm === algorithmName
+        );
+        if (!baseFingerprint || !workingFingerprint) {
+          console.warn(
+            `No ${algorithmName} fingerprint found on AppMap ${name}`
+          );
+          return;
+        }
+
+        if (baseFingerprint.digest !== workingFingerprint.digest) {
+          result.push(name);
+        }
+      });
+    return result;
+  }
+
+  _includesAppMap(name) {
+    return !this.appMapNames || this.appMapNames.has(name);
+  }
+
+  // eslint-disable-next-line no-underscore-dangle
+  async _loadCatalogs() {
+    if (!this.workingDir) {
+      throw new Error('Working directory must be specified');
+    }
+    // TODO: Other modes of loading the base data, such as from a remote server, can be supported
+    // in the future.
+    if (!this.baseDir) {
+      throw new Error('Base directory must be specified');
+    }
+
+    this.workingCatalog = await appMapCatalog(this.workingDir);
+    this.baseCatalog = await appMapCatalog(this.baseDir);
+
+    this.workingAppMapNames = new Set(
+      Object.keys(this.workingCatalog).filter(this._includesAppMap.bind(this))
+    );
+    this.baseAppMapNames = new Set(
+      Object.keys(this.baseCatalog).filter(this._includesAppMap.bind(this))
+    );
+  }
+}
+
+class DetailedDiff {
+  constructor(algorithm, baseAppMap, workingAppMap) {
+    this.algorithm = algorithm;
+    this.baseAppMap = baseAppMap;
+    this.workingAppMap = workingAppMap;
+  }
+
+  async diff() {
+    const canonicalizeAppMap = (appmap) => {
+      const canonicalForm = canonicalize(this.algorithm, appmap);
+      return yaml.dump(canonicalForm);
+    };
+    const baseDoc = canonicalizeAppMap(this.baseAppMap);
+    const workingDoc = canonicalizeAppMap(this.workingAppMap);
+    return diffLines(baseDoc, workingDoc);
+  }
+}
+
+// eslint-disable-next-line no-unused-expressions
+yargs(process.argv.slice(2))
+  .command(
+    'diff',
+    'Compute the difference between two mapsets',
+    (args) => {
+      args.option('name', {
+        describe: 'indicate a specific AppMap to of compare',
+      });
+      args.option('show-diff', {
+        describe:
+          'compute the diff of the canonicalized forms of each changed AppMap',
+        boolean: true,
+      });
+      args.option('base-dir', {
+        describe: 'directory containing base version AppMaps',
+      });
+      args.option('working-dir', {
+        describe: 'directory containing work-in-progress AppMaps',
+      });
+    },
+    async function (argv) {
+      verbose(argv.verbose);
+
+      let baseDir;
+      let workingDir;
+      const { showDiff } = argv;
+
+      // eslint-disable-next-line prefer-const
+      baseDir = argv.baseDir;
+      // eslint-disable-next-line prefer-const
+      workingDir = argv.workingDir;
+
+      if (!baseDir) {
+        throw new Error('Location of base version AppMaps is required');
+      }
+      if (!workingDir) {
+        throw new Error('Location of work-in-progress AppMaps is required');
+      }
+
+      const diff = new DiffCommand().baseDir(baseDir).workingDir(workingDir);
+      if (argv.name) {
+        diff.setAppMapNames([argv.name]);
+      }
+
+      const diffObject = {
+        added: [...(await diff.added())].sort(),
+        changed: [],
+      };
+
+      const cumulativeChangedAppMaps = new Set();
+      const changed = await Promise.all(
+        Object.keys(algorithms)
+          .map(function (algorithm) {
+            return async function () {
+              const rawList = await diff.changed(algorithm);
+              const changedAppMaps = rawList.filter(
+                (name) => !cumulativeChangedAppMaps.has(name)
+              );
+              changedAppMaps.forEach((name) =>
+                cumulativeChangedAppMaps.add(name)
+              );
+              const changeResult = {
+                algorithm,
+                changed: [],
+              };
+              if (changedAppMaps.length > 0) {
+                if (showDiff) {
+                  changeResult.changed = await Promise.all(
+                    changedAppMaps.map(
+                      // eslint-disable-next-line prettier/prettier
+                      async function (name) {
+                        return {
+                          name,
+                          diff: await new DetailedDiff(
+                            algorithm,
+                            await loadAppMap(diff.baseCatalog[name].fileName),
+                            await loadAppMap(diff.workingCatalog[name].fileName)
+                          ).diff(),
+                        };
+                      }
+                    )
+                  );
+                } else {
+                  changeResult.changed = changedAppMaps.map((name) => ({
+                    name,
+                  }));
+                }
+              }
+              return changeResult;
+            };
+          })
+          .map((func) => func())
+      );
+      diffObject.changed = changed;
+      diffObject.removed = [...(await diff.removed())].sort();
+
+      console.log(yaml.dump(diffObject));
+    }
+  )
+  .command(
+    'depends [files]',
+    'Compute a list of AppMaps that are out of date',
+    (args) => {
+      args.positional('files', {
+        describe: 'provide an explicit list of dependency files',
+      });
+      args.option('appmap-dir', {
+        describe: 'directory to recursively inspect for AppMaps',
+        default: 'tmp/appmap',
+      });
+      args.option('base-dir', {
+        describe: 'directory to prepend to each dependency source file',
+        default: '.',
+      });
+      args.option('field', {
+        describe: 'print a field from each matching AppMap',
+      });
+      args.option('stdin-files', {
+        describe:
+          'read the list of changed files from stdin, one file per line',
+        boolean: true,
+      });
+      return args.strict();
+    },
+    async (argv) => {
+      verbose(argv.verbose);
+
+      let { files } = argv;
+      if (argv.stdinFiles) {
+        const stdinFileStr = readFileSync(0).toString();
+        const stdinFiles = stdinFileStr.split('\n');
+        files = (files || []).concat(stdinFiles);
+        if (verbose()) {
+          console.warn(`Computing depends on ${files.join(', ')}`);
+        }
+      }
+
+      if (verbose()) {
+        console.warn(`Testing AppMaps in ${argv.appmapDir}`);
+      }
+
+      const depends = new Depends(argv.appmapDir);
+      if (argv.baseDir) {
+        depends.baseDir = argv.baseDir;
+      }
+      if (files) {
+        depends.files = files;
+      }
+
+      const appMapNames = await depends.depends();
+      const values = [];
+      if (argv.field) {
+        const { field } = argv;
+        // eslint-disable-next-line no-inner-declarations
+        async function printField(appMapBaseName) {
+          const data = await fsp.readFile(
+            join(appMapBaseName, 'metadata.json')
+          );
+          const metadata = JSON.parse(data);
+          const value = metadata[field];
+          if (value) {
+            const tokens = value.split(':');
+            values.push(tokens[0]);
+          } else {
+            console.warn(`No ${field} in ${appMapBaseName}`);
+          }
+        }
+        const q = queue(printField, 5);
+        appMapNames.forEach((name) => q.push(name));
+        await q.drain();
+      } else {
+        appMapNames.forEach((name) => values.push(name));
+      }
+      console.log([...new Set(values)].sort().join('\n'));
+    }
+  )
+  .command(
+    'inspect <code-object>',
+    'Search AppMaps for references to a code object (package, function, class, query, route, etc) and print available event info',
+    (args) => {
+      args.positional('code-object', {
+        describe: 'identifies the code-object to inspect',
+      });
+      args.option('appmap-dir', {
+        describe: 'directory to recursively inspect for AppMaps',
+        default: 'tmp/appmap',
+      });
+      args.option('interactive', {
+        describe: 'interact with the output via CLI',
+        alias: 'i',
+        boolean: true,
+      });
+      return args.strict();
+    },
+    async (argv) => {
+      verbose(argv.verbose);
+
+      const newProgress = () => {
+        if (argv.interactive) {
+          return new cliProgress.SingleBar(
+            {},
+            cliProgress.Presets.shades_classic
+          );
+        }
+
+        return {
+          increment: () => {},
+          start: () => {},
+          stop: () => {},
+        };
+      };
+
+      console.warn('Indexing the AppMap database');
+      await new FingerprintDirectoryCommand(argv.appmapDir).execute();
+
+      console.warn('Finding matching AppMaps');
+      let progress = newProgress();
+      const codeObjectId = argv.codeObject;
+      const finder = new FindCodeObjects(argv.appmapDir, codeObjectId);
+      const codeObjectMatches = await finder.find(
+        (count) => progress.start(count, 0),
+        progress.increment.bind(progress)
+      );
+      progress.stop();
+
+      if (!codeObjectMatches) {
+        return;
+      }
+
+      const filters = [];
+      let stats = null;
+
+      const buildStats = async () => {
+        const result = [];
+        console.warn('Finding matching Events');
+        progress = newProgress();
+        progress.start(codeObjectMatches.length, 0);
+        await Promise.all(
+          codeObjectMatches.map(async (codeObjectMatch) => {
+            const findEvents = new FindEvents(
+              codeObjectMatch.appmap,
+              codeObjectMatch.codeObject
+            );
+            findEvents.filter(filters);
+            const events = await findEvents.matches();
+            result.push(...events);
+            progress.increment();
+          })
+        );
+        progress.stop();
+        console.warn('Collating results...');
+        stats = new FunctionStats(result);
+      };
+
+      await buildStats();
+
+      const interactive = () => {
+        const rl = readline.createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+        rl.on('close', function () {
+          process.exit(0);
+        });
+
+        const home = () => {
+          Inspect.home(codeObjectId, filters, stats, getCommand);
+        };
+
+        const filter = () => {
+          Inspect.filter(rl, filters, stats, buildStats, home);
+        };
+
+        const undoFilter = async () => {
+          await Inspect.undoFilter(filters, buildStats, home);
+        };
+
+        const reset = async () => {
+          await Inspect.reset(filters, buildStats, home);
+        };
+
+        const print = () => {
+          Inspect.print(stats, rl, getCommand, home);
+        };
+
+        const getCommand = () => {
+          console.log();
+          rl.question(
+            'Command (h)ome, (p)rint, (f)ilter, (u)ndo filter, (r)eset filters, (q)uit: ',
+            function (command) {
+              // eslint-disable-next-line default-case
+              switch (command) {
+                case 'h':
+                  home();
+                  break;
+                case 'p':
+                  print();
+                  break;
+                case 'f':
+                  filter();
+                  break;
+                case 'u':
+                  undoFilter();
+                  break;
+                case 'r':
+                  reset();
+                  break;
+                case 'q':
+                  rl.close();
+                  break;
+                default:
+                  getCommand();
+              }
+            }
+          );
+        };
+
+        home();
+      };
+      if (argv.interactive) {
+        interactive();
+      } else {
+        console.log(JSON.stringify(stats, null, 2));
+      }
+    }
+  )
+  .command(
+    'index',
+    'Compute fingerprints and update index files for all appmaps in a directory',
+    (args) => {
+      args.option('watch', {
+        describe: 'watch the directory for changes to appmaps',
+        boolean: true,
+      });
+      args.option('appmap-dir', {
+        describe: 'directory to recursively inspect for AppMaps',
+        default: 'tmp/appmap',
+      });
+      return args.strict();
+    },
+    (argv) => {
+      verbose(argv.verbose);
+
+      if (argv.watch) {
+        const cmd = new FingerprintWatchCommand(argv.appmapDir);
+        cmd.execute();
+
+        // eslint-disable-next-line no-inner-declarations
+        function printStatus() {
+          process.stdout.write('\x1B[?25l');
+          const consoleLabel = 'AppMaps processed: 0';
+          process.stdout.write(consoleLabel);
+          setInterval(() => {
+            readline.cursorTo(process.stdout, consoleLabel.length - 1);
+            process.stdout.write(`${cmd.numProcessed}`);
+          }, 200);
+
+          process.on('beforeExit', (/* _code */) => {
+            process.stdout.write(`\x1B[?25h`);
+          });
+        }
+
+        if (!argv.verbose) {
+          printStatus();
+        }
+      } else {
+        new FingerprintDirectoryCommand(argv.appmapDir).execute();
+      }
+    }
+  )
+  .command(
+    'inventory',
+    'Generate canonical lists of the application code object inventory',
+    (args) => {
+      args.option('appmap-dir', {
+        describe: 'directory to recursively inspect for AppMaps',
+        default: 'tmp/appmap',
+      });
+    },
+    async (argv) => {
+      verbose(argv.verbose);
+
+      await new FingerprintDirectoryCommand(argv.appmapDir).execute();
+
+      const inventory = await new InventoryCommand(argv.appmapDir).execute();
+      console.log(yaml.dump(inventory));
+    }
+  )
+  .command(
+    'swagger',
+    'Generate Swagger from AppMaps in a directory',
+    (args) => {
+      args.option('appmap-dir', {
+        describe: 'directory to recursively inspect for AppMaps',
+        default: 'tmp/appmap',
+      });
+    },
+    async (argv) => {
+      verbose(argv.verbose);
+
+      const swagger = await new SwaggerCommand(argv.appmapDir).execute();
+      console.log(yaml.dump(swagger));
+    }
+  )
+  .option('verbose', {
+    alias: 'v',
+    type: 'boolean',
+    description: 'Run with verbose logging',
+  })
+  .strict()
+  .demandCommand()
+  .help().argv;