@atlaspack/query 2.12.1-canary.3354

package/lib/cli.js

@@ -0,0 +1,850 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.run = run;
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _fs() {
+  const data = _interopRequireDefault(require("fs"));
+  _fs = function () {
+    return data;
+  };
+  return data;
+}
+function _repl() {
+  const data = _interopRequireDefault(require("repl"));
+  _repl = function () {
+    return data;
+  };
+  return data;
+}
+function _os() {
+  const data = _interopRequireDefault(require("os"));
+  _os = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _v() {
+  const data = require("v8");
+  _v = function () {
+    return data;
+  };
+  return data;
+}
+function _table() {
+  const data = require("table");
+  _table = function () {
+    return data;
+  };
+  return data;
+}
+var _index = require("./index.js");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-console, monorepo/no-internal-import */
+// $FlowFixMe
+const {
+  BundleGraph: {
+    bundleGraphEdgeTypes: bundleGraphEdgeTypes
+  },
+  Priority,
+  fromProjectPathRelative
+} = require('./deep-imports.js');
+async function run(input) {
+  let args = input;
+  let cacheDir = _path().default.join(process.cwd(), '.atlaspack-cache');
+  if (args[0] === '--cache') {
+    cacheDir = _path().default.resolve(process.cwd(), args[1]);
+    args = args.slice(2);
+  }
+  let initialCmd = args[0];
+  try {
+    _fs().default.accessSync(cacheDir);
+  } catch (e) {
+    console.error("Can't find cache dir", cacheDir);
+    process.exit(1);
+  }
+  console.log('Loading graphs...');
+  let {
+    assetGraph,
+    bundleGraph,
+    bundleInfo,
+    requestTracker,
+    cacheInfo
+  } = await (0, _index.loadGraphs)(cacheDir);
+  function hasRequestTracker() {
+    if (requestTracker == null) {
+      console.error('Request Graph could not be found');
+      return false;
+    }
+    return true;
+  }
+  function hasBundleGraph() {
+    if (bundleGraph == null) {
+      console.error('Bundle Graph could not be found');
+      return false;
+    }
+    return true;
+  }
+  function hasAssetGraph() {
+    if (assetGraph == null) {
+      console.error('Asset Graph could not be found');
+      return false;
+    }
+    return true;
+  }
+  function hasBundleInfo() {
+    if (bundleInfo == null) {
+      console.error('Bundle Info could not be found');
+      return false;
+    }
+    return true;
+  }
+
+  // -------------------------------------------------------
+
+  function getBundleFilePath(id) {
+    var _bundleInfo$get;
+    if (!hasBundleInfo()) {
+      return;
+    }
+    (0, _assert().default)(bundleInfo != null);
+    return fromProjectPathRelative((0, _nullthrows().default)((_bundleInfo$get = bundleInfo.get(id)) === null || _bundleInfo$get === void 0 ? void 0 : _bundleInfo$get.filePath));
+  }
+  function parseAssetLocator(v) {
+    let id = null;
+    if (v.length === 16) {
+      id = v;
+    } else {
+      if (!hasBundleGraph()) {
+        return;
+      }
+      (0, _assert().default)(bundleGraph != null);
+      for (let [assetId, publicId] of bundleGraph._publicIdByAssetId) {
+        if (publicId === v) {
+          id = assetId;
+          break;
+        }
+      }
+    }
+    if (id == null && v.length > 0) {
+      if (!hasAssetGraph()) {
+        return;
+      }
+      (0, _assert().default)(assetGraph != null);
+      let assetRegex = new RegExp(v);
+      for (let node of assetGraph.nodes.values()) {
+        if ((node === null || node === void 0 ? void 0 : node.type) === 'asset' && assetRegex.test(fromProjectPathRelative(node.value.filePath))) {
+          id = node.id;
+          break;
+        }
+      }
+    }
+    return id;
+  }
+  function parseBundleLocator(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleRegex = new RegExp(v);
+    for (let b of bundleGraph.getBundles()) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined && bundleRegex.test(bundleFilePath) || b.id === v) {
+        return b.id;
+      }
+    }
+  }
+  function getAsset(v) {
+    let id = parseAssetLocator(v);
+    if (id == null) {
+      console.log(null);
+    } else {
+      try {
+        if (!hasBundleGraph()) {
+          return;
+        }
+        (0, _assert().default)(bundleGraph != null);
+        let asset = bundleGraph.getAssetById(id);
+        console.log('Public id', bundleGraph.getAssetPublicId(asset));
+        console.log(asset);
+      } catch (e) {
+        if (!hasAssetGraph()) {
+          return;
+        }
+        (0, _assert().default)(assetGraph != null);
+        let node = (0, _nullthrows().default)(assetGraph.getNodeByContentKey(id));
+        (0, _assert().default)(node.type === 'asset');
+        console.log(node.value);
+      }
+    }
+  }
+  function _findAssetNode(v) {
+    if (!hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(assetGraph != null);
+    let assetRegex = new RegExp(v);
+    for (let node of assetGraph.nodes.values()) {
+      if ((node === null || node === void 0 ? void 0 : node.type) === 'asset' && assetRegex.test(fromProjectPathRelative(node.value.filePath))) {
+        return node;
+      }
+    }
+  }
+  function findAsset(v) {
+    let node = _findAssetNode(v);
+    if (node) {
+      try {
+        if (!hasBundleGraph()) {
+          return;
+        }
+        (0, _assert().default)(bundleGraph != null);
+        console.log(`${bundleGraph.getAssetPublicId(bundleGraph.getAssetById(node.id))} ${fromProjectPathRelative(node.value.filePath)}`);
+      } catch (e) {
+        console.log(fromProjectPathRelative(node.value.filePath));
+      }
+    }
+  }
+  function findAssetWithSymbol(local) {
+    if (!hasBundleGraph() || !hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    (0, _assert().default)(assetGraph != null);
+    let [, assetId, binding, ref] = (0, _nullthrows().default)(local.match(/^\$([^$]+)\$([^$]+)\$(.*)$/), `symbol ${local} could not be resolved`);
+    let asset;
+    // Search against the id used by the JSTransformer and ScopeHoistingPackager,
+    // not the final asset id, as it may have changed with further transformation.
+    for (let node of assetGraph.nodes.values()) {
+      if ((node === null || node === void 0 ? void 0 : node.type) === 'asset' && node.value.meta.id === assetId) {
+        asset = node;
+        break;
+      }
+    }
+
+    // If the asset couldn't be found by searching for the id,
+    // search for the local name in asset used symbols.
+    if (asset == null) {
+      outer: for (let node of assetGraph.nodes.values()) {
+        if ((node === null || node === void 0 ? void 0 : node.type) === 'asset' && node.value.symbols) {
+          for (let symbol of node.value.symbols.values()) {
+            if (symbol.local === local) {
+              asset = node;
+              break outer;
+            }
+          }
+        }
+      }
+    }
+    (0, _assert().default)(asset, `An asset for ${assetId} could not be found`);
+    (0, _assert().default)(asset.type === 'asset', `Expected ${assetId} to be an asset, but found a ${asset.type}`);
+    try {
+      console.log(`${bundleGraph.getAssetPublicId(bundleGraph.getAssetById(asset.id))} ${fromProjectPathRelative(asset.value.filePath)}`);
+    } catch (e) {
+      console.log(fromProjectPathRelative(asset.value.filePath));
+    }
+    if (binding === 'export' && asset.value.symbols) {
+      for (let [symbolName, symbol] of asset.value.symbols) {
+        if (symbol.local === local) {
+          if (symbol.loc) {
+            let locPath = symbol.loc.filePath;
+            let locAsset = _findAssetNode(String(locPath));
+            if (locAsset != null) {
+              try {
+                console.log(`${bundleGraph.getAssetPublicId(bundleGraph.getAssetById(locAsset.id))} ${fromProjectPathRelative(locAsset.value.filePath)}`);
+              } catch (e) {
+                console.log(`imported as ${symbolName} from ${fromProjectPathRelative(locAsset.value.filePath)}`);
+              }
+            } else {
+              console.log(`imported as ${symbolName} from ${fromProjectPathRelative(locPath)}`);
+            }
+          } else {
+            console.log(`imported as ${symbolName}`);
+          }
+        }
+      }
+    } else if (ref) {
+      console.log(`possibly defined as ${ref}`);
+    }
+  }
+  function getNodeAssetGraph(v) {
+    if (!hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(assetGraph != null);
+    console.log(assetGraph.getNodeByContentKey(v));
+  }
+  function getNodeBundleGraph(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    console.log(bundleGraph._graph.getNodeByContentKey(v));
+  }
+  class Paths {
+    children = [];
+    constructor(value, label = '-', suffix = '') {
+      this.value = value;
+      this.label = label;
+      this.suffix = suffix;
+    }
+    add(v, label, suffix) {
+      let next = new Paths(v, label, suffix);
+      this.children.push(next);
+      return next;
+    }
+    print(format, prefix = '') {
+      console.log(`${prefix}${this.label} ${format(this.value)} ${this.suffix}`);
+      for (let i = 0; i < this.children.length; i++) {
+        this.children[i].print(format, prefix + '  ');
+      }
+    }
+  }
+  function _findEntries(graph, v) {
+    let asset = (0, _nullthrows().default)(parseAssetLocator(v), 'Asset not found');
+    let paths = new Paths(graph.getNodeIdByContentKey(asset), ' ');
+    let cb = (id, ctx, revisiting) => {
+      let {
+        paths,
+        lazyOutgoing
+      } = ctx;
+      let node = (0, _nullthrows().default)(graph.getNode(id));
+      if (node.id === asset) return ctx;
+      if (node.type === 'asset') {
+        paths = paths.add(id, lazyOutgoing ? '<' : undefined, revisiting ? '(revisiting)' : undefined);
+        lazyOutgoing = false;
+      } else if (node.type === 'dependency') {
+        if (node.value.priority === Priority.lazy) {
+          lazyOutgoing = true;
+        }
+      }
+      return {
+        paths,
+        lazyOutgoing
+      };
+    };
+
+    // like graph.dfs, but revisiting nodes and skipping its children
+    let seen = new Set();
+    function walk(id, ctx) {
+      let revisiting = seen.has(id);
+      let newCtx = cb(id, ctx, revisiting);
+      if (revisiting) return;
+      seen.add(id);
+      for (let parent of graph.getNodeIdsConnectedTo(id)) {
+        walk(parent, newCtx);
+      }
+    }
+    walk(graph.getNodeIdByContentKey(asset), {
+      paths,
+      lazyOutgoing: false
+    });
+    paths.print(id => {
+      let node = (0, _nullthrows().default)(graph.getNode(id));
+      (0, _assert().default)(node.type === 'asset');
+      return fromProjectPathRelative(node.value.filePath);
+    });
+  }
+  function findEntriesAssetGraph(v) {
+    if (!hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(assetGraph != null);
+    _findEntries(assetGraph, v);
+  }
+  function findEntriesBundleGraph(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    _findEntries(bundleGraph._graph, v);
+  }
+  function findEntries(v) {
+    findEntriesBundleGraph(v);
+  }
+  function getBundlesWithAsset(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let asset = (0, _nullthrows().default)(parseAssetLocator(v), 'Asset not found');
+    for (let b of bundleGraph.getBundlesWithAsset(bundleGraph.getAssetById(asset))) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined) {
+        console.log(`${b.id} ${bundleFilePath} ${b.mainEntryId != null ? `(main: ${b.mainEntryId})` : ''}`);
+      }
+    }
+  }
+  function getBundlesWithDependency(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(v));
+    (0, _assert().default)(node.type === 'dependency');
+    for (let b of bundleGraph.getBundlesWithDependency(node.value)) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined) {
+        console.log(`${b.id} ${bundleFilePath} ${b.mainEntryId != null ? `(main: ${b.mainEntryId})` : ''}`);
+      }
+    }
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  function getBundles(_) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    for (let b of bundleGraph.getBundles()) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined) {
+        console.log(`${b.id} ${bundleFilePath} ${b.mainEntryId != null ? `(main: ${b.mainEntryId})` : ''}`);
+      }
+    }
+  }
+  function getReferencingBundles(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleId = (0, _nullthrows().default)(parseBundleLocator(v), 'Bundle not found');
+    let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundleId);
+    let bundleNode = (0, _nullthrows().default)(bundleGraph._graph.getNode(bundleNodeId), 'Bundle not found');
+    (0, _assert().default)(bundleNode.type === 'bundle', 'Not a bundle');
+    for (let b of bundleGraph.getReferencingBundles(bundleNode.value)) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined) {
+        console.log(`${b.id} ${bundleFilePath} ${b.mainEntryId != null ? `(main: ${b.mainEntryId})` : ''}`);
+      }
+    }
+  }
+  function getIncomingDependenciesAssetGraph(v) {
+    if (!hasAssetGraph()) {
+      return;
+    }
+    (0, _assert().default)(assetGraph != null);
+    let asset = (0, _nullthrows().default)(parseAssetLocator(v), 'Asset not found');
+    let node = (0, _nullthrows().default)(assetGraph.getNodeByContentKey(asset));
+    (0, _assert().default)(node.type === 'asset');
+    console.log(assetGraph.getIncomingDependencies(node.value));
+  }
+  function getIncomingDependenciesBundleGraph(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let asset = (0, _nullthrows().default)(parseAssetLocator(v), 'Asset not found');
+    let value = (0, _nullthrows().default)(bundleGraph.getAssetById(asset));
+    console.log(bundleGraph.getIncomingDependencies(value));
+  }
+  function getIncomingDependencies(v) {
+    getIncomingDependenciesBundleGraph(v);
+  }
+  function getResolvedAsset(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(v), 'Dependency not found');
+    (0, _assert().default)(node.type === 'dependency', 'Node is not a dependency, but a ' + node.type);
+    console.log(bundleGraph.getResolvedAsset(node.value));
+  }
+  function getAssetWithDependency(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(v), 'Dependency not found');
+    (0, _assert().default)(node.type === 'dependency', 'Node is not a dependency, but a ' + node.type);
+    console.log(bundleGraph.getAssetWithDependency(node.value));
+  }
+  function traverseAssets(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleId = (0, _nullthrows().default)(parseBundleLocator(v), 'Bundle not found');
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(bundleId), 'Bundle not found');
+    (0, _assert().default)(node.type === 'bundle', 'Node is not a bundle, but a ' + node.type);
+    bundleGraph.traverseAssets(node.value, asset => {
+      console.log(asset.id, asset.filePath);
+    });
+  }
+  function traverseBundle(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleId = (0, _nullthrows().default)(parseBundleLocator(v), 'Bundle not found');
+    let node = (0, _nullthrows().default)(bundleGraph._graph.getNodeByContentKey(bundleId), 'Bundle not found');
+    (0, _assert().default)(node.type === 'bundle', 'Node is not a bundle, but a ' + node.type);
+    bundleGraph.traverseBundle(node.value, node => {
+      if (node.type === 'asset') {
+        console.log(node.id, node.value.filePath);
+      } else {
+        console.log(node.id, node.value.sourcePath, '->', node.value.specifier, node.value.symbols ? `(${[...node.value.symbols.keys()].join(',')})` : '', node.excluded ? `- excluded` : '');
+      }
+    });
+  }
+  function getBundle(v) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleRegex = new RegExp(v);
+    for (let b of bundleGraph.getBundles()) {
+      let bundleFilePath = getBundleFilePath(b.id);
+      if (bundleFilePath !== undefined && bundleRegex.test(bundleFilePath) || b.id === v) {
+        console.log(getBundleFilePath(b.id), b);
+      }
+    }
+  }
+  function findBundleReason(bundle, asset) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bundleId = (0, _nullthrows().default)(parseBundleLocator(bundle), 'Bundle not found');
+    let bundleNodeId = bundleGraph._graph.getNodeIdByContentKey(bundleId);
+    let bundleNode = (0, _nullthrows().default)(bundleGraph._graph.getNode(bundleNodeId), 'Bundle not found');
+    (0, _assert().default)(bundleNode.type === 'bundle', 'Not a bundle');
+    let assetId = (0, _nullthrows().default)(parseAssetLocator(asset), 'Asset not found');
+    let assetNodeId = bundleGraph._graph.getNodeIdByContentKey(assetId);
+    let assetNode = (0, _nullthrows().default)(bundleGraph._graph.getNode(assetNodeId), 'Asset not found');
+    (0, _assert().default)(assetNode.type === 'asset', 'Not an asset');
+    (0, _assert().default)(bundleGraph._graph.hasEdge(bundleNodeId, assetNodeId, bundleGraphEdgeTypes.contains), 'Asset is not part of the bundle');
+    console.log('# Asset is main entry of bundle:', bundleNode.value.mainEntryId === assetId);
+    console.log('# Asset is an entry of bundle:', bundleNode.value.entryAssetIds.includes(assetId));
+    console.log('# Incoming dependencies contained in the bundle:');
+    for (let incoming of bundleGraph._graph.getNodeIdsConnectedTo(assetNodeId)) {
+      if (bundleGraph._graph.hasEdge(bundleNodeId, incoming, bundleGraphEdgeTypes.contains)) {
+        console.log(bundleGraph._graph.getNode(incoming));
+      }
+    }
+    console.log('# Incoming dependencies contained in referencing bundles (using this bundle as a shared bundle)');
+    let referencingBundles = bundleGraph.getReferencingBundles(bundleNode.value);
+    for (let incoming of bundleGraph._graph.getNodeIdsConnectedTo(assetNodeId)) {
+      if (referencingBundles.some(ref => bundleGraph._graph.hasEdge(bundleGraph._graph.getNodeIdByContentKey(ref.id), incoming, bundleGraphEdgeTypes.contains))) {
+        console.log(bundleGraph._graph.getNode(incoming));
+      }
+    }
+  }
+  function _getIncomingNodeOfType(bundleGraph, node, type) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    const bundleGraphNodeId = bundleGraph._graph.getNodeIdByContentKey(node.id);
+    return bundleGraph._graph.getNodeIdsConnectedTo(bundleGraphNodeId, -1).map(id => (0, _nullthrows().default)(bundleGraph._graph.getNode(id))).find(node => node.type == type);
+  }
+
+  // We find the priority of a Bundle or BundleGroup by looking at its incoming dependencies.
+  // If a Bundle does not have an incoming dependency, we look for an incoming BundleGroup and its dependency
+  // e.g. Dep(priority = 1) -> BundleGroup -> Bundle means that the Bundle has priority 1.
+  function _getBundlePriority(bundleGraph, bundle) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let node = _getIncomingNodeOfType(bundleGraph, bundle, 'dependency');
+    if (node == null) {
+      node = _getIncomingNodeOfType(bundleGraph, bundle, 'bundle_group');
+      if (node == null) return null;
+      node = _getIncomingNodeOfType(bundleGraph, node, 'dependency');
+    }
+    if (node == null) return null;
+    (0, _assert().default)(node.type === 'dependency', 'Not a dependency');
+    return node.value.priority;
+  }
+  function _findEntryBundle(bundleGraph, node) {
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    const bundleGraphNodeId = bundleGraph._graph.getNodeIdByContentKey(node.id);
+    const entryBundleGroup = bundleGraph._graph.getNodeIdsConnectedTo(bundleGraphNodeId, -1).map(id => (0, _nullthrows().default)(bundleGraph._graph.getNode(id))).find(node => node.type === 'bundle_group' && bundleGraph.isEntryBundleGroup(node.value));
+    return entryBundleGroup;
+  }
+  // eslint-disable-next-line no-unused-vars
+  function inspectCache(_) {
+    // displays sizing of various entries of the cache
+    let table = [];
+    table.push(['Graphs', 'Size (bytes)', 'Deserialize (ms)', 'Serialize (ms)']);
+    let serialized = new Map();
+    serialized.set('RequestGraph', timeSerialize(requestTracker));
+    serialized.set('BundleGraph', timeSerialize(bundleGraph));
+    serialized.set('AssetGraph', timeSerialize(assetGraph));
+    for (let [name, info] of (0, _nullthrows().default)(cacheInfo).entries()) {
+      if (name === 'RequestGraph' && !hasRequestTracker() || name === 'BundleGraph' && !hasBundleGraph() || name === 'AssetGraph' && !hasAssetGraph()) {
+        continue;
+      }
+      let s = serialized.get(name);
+      (0, _assert().default)(s != null);
+      table.push([name, ...info, s]);
+    }
+    function getColumnSum(t, col) {
+      if (t == null) {
+        return '';
+      }
+      const initialValue = 0;
+      let column = t.map(r => r[col]);
+      column.shift();
+      (0, _assert().default)(column != null);
+      return column.reduce((accumulator, currentValue) => accumulator + currentValue, initialValue);
+    }
+    table.push(['Totals', getColumnSum(table, 1), getColumnSum(table, 2), getColumnSum(table, 3)]);
+    _printStatsTable('Cache Info', table);
+  }
+  function timeSerialize(graph) {
+    let date = Date.now();
+    (0, _v().serialize)(graph);
+    date = Date.now() - date;
+    return date;
+  }
+  function _printStatsTable(header, data) {
+    const config = {
+      columnDefault: {
+        width: 18
+      },
+      header: {
+        alignment: 'center',
+        content: header
+      }
+    };
+    console.log((0, _table().table)(data, config));
+  }
+
+  // eslint-disable-next-line no-unused-vars
+  function stats(_) {
+    let ag = {
+      asset: 0,
+      dependency: 0,
+      asset_group: 0
+    };
+    if (hasAssetGraph()) {
+      (0, _assert().default)(assetGraph != null);
+      for (let n of assetGraph.nodes) {
+        if (n && n.type in ag) {
+          // $FlowFixMe
+          ag[n.type]++;
+        }
+      }
+      _printStatsTable('# Asset Graph Node Counts', Object.entries(ag));
+    }
+    if (!hasBundleGraph()) {
+      return;
+    }
+    (0, _assert().default)(bundleGraph != null);
+    let bg = {
+      dependency: 0,
+      bundle: 0,
+      bundle_group: 0,
+      asset_node_modules: 0,
+      asset_source: 0
+    };
+    let b_type = {
+      entry: 0,
+      shared: 0,
+      async: 0,
+      parallel: 0,
+      sync: 0
+    };
+    let b_ext = {};
+    const entries = new Set();
+    for (let n of bundleGraph._graph.nodes) {
+      if ((n === null || n === void 0 ? void 0 : n.type) === 'bundle_group') {
+        bg.bundle_group++;
+      } else if ((n === null || n === void 0 ? void 0 : n.type) === 'bundle') {
+        bg.bundle++;
+
+        // $FlowFixMe
+        b_ext[n.value.type] = (b_ext[n.value.type] || 0) + 1;
+
+        // $FlowFixMe
+        const entry_group = _findEntryBundle(bundleGraph, n);
+        if (entry_group != null && !entries.has(entry_group.id)) {
+          b_type.entry++;
+          entries.add(entry_group.id);
+        } else if (n.value.mainEntryId == null) {
+          // In general, !bundle.mainEntryId means that it is shared. In the case of an async and shared bundle, only count it as shared.
+          b_type.shared++;
+        } else {
+          const priority = _getBundlePriority(bundleGraph, n);
+          if (priority == Priority.lazy) {
+            b_type.async++;
+          } else if (priority == Priority.parallel) {
+            b_type.parallel++;
+          } else if (priority == Priority.sync) {
+            b_type.sync++;
+          }
+        }
+      } else if ((n === null || n === void 0 ? void 0 : n.type) === 'asset') {
+        if (
+        // $FlowFixMe
+        fromProjectPathRelative(n.value.filePath).includes('node_modules')) {
+          bg.asset_node_modules++;
+        } else {
+          bg.asset_source++;
+        }
+      } else if ((n === null || n === void 0 ? void 0 : n.type) === 'dependency') {
+        bg.dependency++;
+      }
+    }
+    _printStatsTable('# Bundle Graph Node Counts', Object.entries(bg));
+    _printStatsTable('# Bundles By Type', Object.entries(b_type));
+    _printStatsTable('# Bundles By Extension', Object.entries(b_ext));
+
+    // Assert that counts for each breakdown are correct
+
+    let sum_b_ext = 0;
+    for (let k in b_ext) {
+      sum_b_ext += b_ext[k];
+    }
+    let sum_b_type = 0;
+    for (let k in b_type) {
+      sum_b_type += b_type[k];
+    }
+    (0, _assert().default)(bg.bundle == sum_b_type, `Bundles by type ${sum_b_type} does not equal total ${bg.bundle}`);
+    (0, _assert().default)(bg.bundle == sum_b_ext, `Bundles by extension ${sum_b_ext} does not equal total ${bg.bundle}`);
+  }
+
+  // -------------------------------------------------------
+
+  if (initialCmd != null) {
+    (async () => {
+      await eval(initialCmd);
+      process.exit(0);
+    })();
+  } else {
+    console.log('See .help. The graphs can be accessed via `assetGraph`, `bundleGraph` and `requestTracker`.');
+    process.on('uncaughtException', function (err) {
+      console.error(err);
+      server.displayPrompt();
+    });
+    const server = _repl().default.start({
+      useColors: true,
+      useGlobal: true
+    });
+    // $FlowFixMe[prop-missing]
+    server.setupHistory(_path().default.join(_os().default.homedir(), '.atlaspack_query_history'), () => {});
+
+    // $FlowFixMe[prop-missing]
+    server.context.bundleGraph = bundleGraph;
+    // $FlowFixMe[prop-missing]
+    server.context.assetGraph = assetGraph;
+    // $FlowFixMe[prop-missing]
+    server.context.requestTracker = requestTracker;
+    // $FlowFixMe[prop-missing]
+    server.context.cacheInfo = cacheInfo;
+    for (let [name, cmd] of new Map([['getAsset', {
+      help: 'args: <id | public id | filepath>',
+      action: getAsset
+    }], ['getNodeAssetGraph', {
+      help: 'args: <content key>. Find node by content key in the asset graph',
+      action: getNodeAssetGraph
+    }], ['getNodeBundleGraph', {
+      help: 'args: <content key>. Find node by content key in the bundle graph',
+      action: getNodeBundleGraph
+    }], ['findEntriesAssetGraph', {
+      help: 'args: <id | public id | filepath>. List paths from an asset to entry points (in asset graph)',
+      action: findEntriesAssetGraph
+    }], ['findEntriesBundleGraph', {
+      help: 'args: <id | public id | filepath>. List paths from an asset to entry points (in bundle graph)',
+      action: findEntriesBundleGraph
+    }], ['findEntries', {
+      help: '= findEntriesBundleGraph',
+      action: findEntries
+    }], ['getBundlesWithAsset', {
+      help: 'args: <id | public id | filepath>. Gets bundles containing the asset',
+      action: getBundlesWithAsset
+    }], ['getBundlesWithDependency', {
+      help: 'args: <id>. Gets bundles containing the dependency',
+      action: getBundlesWithDependency
+    }], ['getIncomingDependenciesAssetGraph', {
+      help: 'args: <asset: id | public id | filepath regex>',
+      action: getIncomingDependenciesAssetGraph
+    }], ['getIncomingDependenciesBundleGraph', {
+      help: 'args: <asset: id | public id | filepath regex>',
+      action: getIncomingDependenciesBundleGraph
+    }], ['getIncomingDependencies', {
+      help: '= getIncomingDependenciesBundleGraph',
+      action: getIncomingDependencies
+    }], ['getResolvedAsset', {
+      help: 'args: <dependency id>. Resolve the dependency',
+      action: getResolvedAsset
+    }], ['getAssetWithDependency', {
+      help: 'args: <dependency id>. Show which asset created the dependency',
+      action: getAssetWithDependency
+    }], ['traverseAssets', {
+      help: 'args: <bundle id>. List assets in bundle',
+      action: traverseAssets
+    }], ['traverseBundle', {
+      help: 'args: <bundle id>. List assets and dependencies in bundle',
+      action: traverseBundle
+    }], ['getBundle', {
+      help: 'args: <name prefix|bundle id>. List matching bundles',
+      action: getBundle
+    }], ['findBundleReason', {
+      help: 'args: <bundle> <asset>. Why is the asset in the bundle',
+      action: v => findBundleReason(...v.split(' '))
+    }], ['getBundles', {
+      help: 'List all bundles',
+      action: getBundles
+    }], ['getReferencingBundles', {
+      help: 'args: <bundle>. List bundles that reference the bundle',
+      action: getReferencingBundles
+    }], ['stats', {
+      help: 'Statistics',
+      action: stats
+    }], ['findAsset', {
+      help: 'args: <regex>. List assets matching the filepath regex',
+      action: findAsset
+    }], ['inspectCache', {
+      help: 'Cache Information',
+      action: inspectCache
+    }], ['findAssetWithSymbol', {
+      help: 'args: <local>. Get the asset that defines the symbol with the given local name',
+      action: findAssetWithSymbol
+    }]])) {
+      // $FlowFixMe
+      server.context[name] = cmd.action;
+      // $FlowFixMe
+      server.defineCommand(name, {
+        // $FlowFixMe
+        help: '📦 ' + cmd.help,
+        action: v => {
+          // $FlowFixMe
+          server.clearBufferedCommand();
+          // $FlowFixMe
+          try {
+            cmd.action(v);
+          } finally {
+            server.displayPrompt();
+          }
+        }
+      });
+    }
+  }
+}