rev-dep 1.0.0-alpha.3 → 1.0.0-alpha.6

package/README.md

@@ -1,16 +1,51 @@
 <h3 align="center">
-  <code>rev🠄dep</code>
+  <code>rev←dep</code>
 </h3>
 
 <p align="center">
-  A small tool for JavaScript project discovery
+  Dependency debugging tool for JavaScript and TypeScript projects
 </p>
 
 ---
 
 <img alt="rev-dep version" src="https://img.shields.io/npm/v/rev-dep"> <img alt="rev-dep license" src="https://img.shields.io/npm/l/rev-dep"> <img alt="rev-dep PRs welcome" src="https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square">
 
-## Installation
+## About
+
+The tool was created help with daily dev struggles by answering these questions:
+
+- What entry points my codebase have
+- Which entry points uses a given file
+- Which dependencies a given file has
+
+This helps to debug project dependencies, plan refactoring, optimize bundles or plan code splitting.
+
+It's especially useful in JS world without TypeScript or tests coverage.
+
+It also helps to identify and eliminate dead files, understand the complexity of the file dependencies
+
+[Jump to CLI reference](#cli-reference)
+
+[`export * from` problem](#export-from-problem)
+
+### Use cases
+
+- [You plan to refactor some file and you wonder which entry points are affected](#how-to-identify-where-a-file-is-used-in-the-project)
+
+- [You are wondering wether a given source file is used](#how-to-check-if-a-file-is-used-in-the-project)
+- [You wonder if there are any dead files in your project](#how-to-identify-dead-files-in-the-project)
+- [You want to verify if a given entry point imports only the required files](#how-to-check-which-files-are-imported-by-a-given-file)
+- [You want to optimize the amount of files imported by an entry point](#how-to-reduce-amount-of-files-imported-by-entry-point)
+
+### How about dependency or bundle graphs?
+
+There are tool that can output nice, visual representation of project dependencies like [webpack-bundle-analyzer](https://www.npmjs.com/package/webpack-bundle-analyzer) or [dependency-cruiser](https://www.npmjs.com/package/dependency-cruiser) (_which btw rev-dep uses for non-TS codebases_)
+
+While graphs can be useful to identify major problems like too big bundle size or to visualize mess in your deps, it's hard to take any action based on them (_at least it was hard for me_ 🤷‍♂️)
+
+`rev-dep` visualize dependencies as lists, so it's really easy to see where to cut the line to solve the problem.
+
+## Getting Started
 
 ### Install globally to use as CLI tool
 
@@ -28,88 +63,297 @@ or
 
 `npm install rev-dep`
 
-## Example
+## Recipes
 
-For this repo
+### How to identify where a file is used in the project?
 
-```sh
-rev-dep resolve getDepsSet.js cli.js
-```
+Just use `rev-dep resolve path/to/file.ts`
+
+You will see all the entry points that implicitly require given file together with resolution path.
+
+[`resolve` Command CLI reference](#command-resolve)
+<details>
+<summary>Example for the rev-dep repository</summary>
+
+command: 
+
+`rev-dep resolve src/lib/utils.ts`
+
+output:
+
+```s
+src/babel/index.js : 
 
-will output
+ ➞ src/babel/index.js
+  ➞ src/lib/utils.ts 
+_____________________
+
+src/cli/index.ts : 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/resolve/index.ts
+    ➞ src/lib/find.ts
+     ➞ src/lib/getDepsTree.ts
+      ➞ src/lib/getDepsSetWebpack.ts
+       ➞ src/lib/utils.ts 
+_____________________
+
+```
+</details>
+
+#### Getting more details about file resolution in given entry point
+
+To find out all paths combination use `rev-dep resolve` with `-a` flag
+
+> You might be surprised how complex dependency tree can be!
+
+<details>
+<summary>Example for the rev-dep repository</summary>
+
+command: 
+
+`rev-dep resolve src/lib/utils.ts src/cli/index.ts --all`
+
+output:
+
+```s
+src/cli/index.ts : 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/resolve/index.ts
+    ➞ src/lib/find.ts
+     ➞ src/lib/getDepsTree.ts
+      ➞ src/lib/getDepsSetWebpack.ts
+       ➞ src/lib/utils.ts 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/resolve/index.ts
+    ➞ src/lib/find.ts
+     ➞ src/lib/getEntryPoints.ts
+      ➞ src/lib/getDepsTree.ts
+       ➞ src/lib/getDepsSetWebpack.ts
+        ➞ src/lib/utils.ts 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/entryPoints/index.ts
+    ➞ src/lib/getEntryPoints.ts
+     ➞ src/lib/getDepsTree.ts
+      ➞ src/lib/getDepsSetWebpack.ts
+       ➞ src/lib/utils.ts 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/files/index.ts
+    ➞ src/lib/getDepsTree.ts
+     ➞ src/lib/getDepsSetWebpack.ts
+      ➞ src/lib/utils.ts 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/resolve/index.ts
+    ➞ src/lib/find.ts
+     ➞ src/lib/getEntryPoints.ts
+      ➞ src/lib/utils.ts 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/entryPoints/index.ts
+    ➞ src/lib/getEntryPoints.ts
+     ➞ src/lib/utils.ts 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/resolve/index.ts
+    ➞ src/lib/find.ts
+     ➞ src/lib/utils.ts 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/resolve/index.ts
+    ➞ src/lib/utils.ts 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/entryPoints/index.ts
+    ➞ src/lib/utils.ts 
+
+ ➞ src/cli/index.ts
+  ➞ src/cli/createCommands.ts
+   ➞ src/cli/files/index.ts
+    ➞ src/lib/utils.ts 
 
 ```
+</details>
+
+### How to check if a file is used in the project?
+
+Use `rev-dep resolve path/to/file.ts --compactSummary` 
+
+As a result you will see total amount of entry points requiring a given file.
+
+> Note that among the entry points list there might be some dead files importing the searched file
+
+[`resolve` Command CLI reference](#command-resolve)
+
+<details>
+<summary>Example for the rev-dep repository</summary>
+
+command: 
+
+`rev-dep resolve src/lib/utils.ts --compactSummary`
+
+output:
+
+```s
 Results:
 
- ➞ cli.js
-  ➞ find.js
-   ➞ getDepsSet.js
+__tests__/find.test.js        : 0
+babel.js                      : 0
+bin.js                        : 0
+scripts/addDocsToReadme.js    : 0
+src/babel/index.js            : 1
+src/cli/index.ts              : 1
+src/lib/getMaxDepthInGraph.ts : 0
+types.d.ts                    : 0
+
+Total: 2
 ```
+</details>
 
-Which says that `getDepsSet.js` file is used in `cli.js` entry point and is required through `find.js`
+### How to identify dead files in the project?
 
-## About
+Use `rev-dep entry-points` to get list of all files that are not required by any other files in the project.
 
-The tool was created to determine places in the project where a particular file is used, to test wether the refactoring do not break functionalities.
+You might want to exclude some file paths that are meant to be actual entry point like `index.js` or `**/pages/**` in `next.js` projects using `--exclude` flag. The same for configuration files like `babel.config.js`
 
-It's especially useful in JS world without TypeScript or tests coverage.
+Review the list and look for suspicious files like `src/ui/components/SomeComponent/index.js`
 
-Except the reverse dependency resolution path, it can print statistics about how many times a particular module is required in the project, which might be helpful for code-splitting planning.
+[`entry-points` command CLI reference](#command-entry-points)
 
-## Usage
+<details>
+<summary>Example for the rev-dep repository</summary>
 
-Project can be used as a CLI tool or as a regular JS module
+command: 
 
-### CLI Tool
+`rev-dep entry-points --exclude '__tests__/**' 'types.d.ts'`
 
-Avaliable commands:
+output:
 
-#### `resolve`
+```s
+babel.js
+bin.js
+scripts/addDocsToReadme.js
+src/babel/index.js
+src/cli/index.ts
+src/lib/getMaxDepthInGraph.ts
 
-```sh
-rev-dep resolve <filePath> <entryPoints...>
 ```
 
-Available options are
+The last one `src/lib/getMaxDepthInGraph.ts` is the source file that is not used at the moment. 
+
+The rest of them looks legit!
+</details>
+
+### How to check which files are imported by a given file?
+
+To get a full list of files imported by given entry point use `rev-dep files path/to/file.ts`. 
+
+You can use `--count` flag if you are interested in the amount.
+
+This is a good indicator of how heavy a given entry point or component is
 
-- `-cs or --compactSummary` - instead of file paths print a compact summary of reverse resolution with a count of found paths
-- `--verbose` - log currently performed operation
-- `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support
+[`files` command CLI reference](#command-files)
+
+<details>
+<summary>Example for the rev-dep repository</summary>
+
+command: 
+
+`rev-dep files files src/cli/index.ts`
+
+output:
+
+```s
+src/cli/index.ts
+src/cli/createCommands.ts
+package.json
+src/cli/resolve/index.ts
+src/cli/docs/index.ts
+src/cli/entryPoints/index.ts
+src/cli/files/index.ts
+src/lib/find.ts
+src/cli/resolve/types.ts
+src/cli/resolve/formatResults.ts
+src/lib/utils.ts
+src/cli/commonOptions.ts
+src/cli/docs/generate.ts
+src/cli/entryPoints/types.ts
+src/lib/getEntryPoints.ts
+src/lib/buildDepsGraph.ts
+src/cli/files/types.ts
+src/lib/getDepsTree.ts
+src/lib/types.ts
+src/cli/docs/template.ts
+src/lib/getDepsSetWebpack.ts
+src/lib/cleanupDpdmDeps.ts
+
+```
+
+As you can see cli even import `package.json`. This is to print version of the cli
+</details>
+
+
+### How to reduce amount of files imported by entry point?
+
+There is no easy how to for this process, but you can do it iteratively using two of the `rev-dep` commands:
+- `files` 
+- `resolve`
+
+1. Get the list of files imported by entry-point 
+  - `rev-dep files path/to/entry-point`
+2. Identify some suspicious files on the list, components that should not be used on the given page or not related utility files
+3. Get all resolution paths for a suspicious file
+  - `rev-dep resolve path/to/suspicious-file path/to/entry-point --all`
+4. You would usually find out that there is some file, like directory `index` file that given entry point is using, which is mandatory, but as a side effect it imports a few files that are redundant for your entry point. In most cases you should be able to decouple the imports or reverse the dependency to cut off the resolution path for the unwanted file
+
+## Usage
+
+Project can be used as a CLI tool or as a module
+
+### CLI Tool
+
+For CLI usage see [CLI reference](#cli-reference)
 
 ### Module
 
-#### `find` Function
+#### `resolve` Function
 
-```js
-import { find } from "rev-dep";
+```ts
+import { resolve } from "rev-dep";
 
-const path = find({
+const paths = resolve({
   entryPoints: ["index.js"],
   filePath: "utils.js",
 });
 
-console.log(path);
+console.log(paths);
 ```
 
-#### `find` Options
+#### `getEntryPoints` Function
 
-- `entryPoints (Array)` - Array of entry points to build a tree for search. Usually it will be one entry point, but project can have many of them, eg. next.js application. **Required**
-- `filePath (String)` - A file that we want to find path for. **Required**
-- `skipRegex (String | RegExp)` - If a file path matches the pattern, we stop to traverse it's dependencies and do not include that file in the search tree. _Optional_, default: `'(node_modules|/__tests__|/__test__|/__mockContent__|.scss)'`
-- `verbose (Boolean)` - when set to true, will print current operation performed by find function. _Optional_, default: `false`
-- `cwd` - root for resolved files, must be an absolute path. _Optional_, default: `process.cwd()`
-- `webpackConfig (String)` - path to webpack config to enable webpack aliases support
+```ts
+import { getEntryPoints } from "rev-dep";
 
-### Additional setup may be required
-
-#### Resolving implicit file extensions
-
-A vast amount of JS/TS projects are configured in a way that allows (or even forces) to skip file extensions in import statements. Rev-dep is strongly based on [dependency-cruiser](https://github.com/sverweij/dependency-cruiser) which by default support implicit file extensions for `*.js, *.cjs, *.mjs, *.jsx` files (check [source](https://github.com/sverweij/dependency-cruiser/blob/96e34d0cf158034f2b7c8cafe9cec72dd74d8c45/src/extract/transpile/meta.js)).
-In order to resolve implicit extensions for other JS based languages it look for available corresponding compiler in `package.json`. If compiler is available, then extension is supported.
-
-If you installed `rev-dep` **globally**, you will have appropriate compiler installed **globally** as well. If you use it as a module, your project has to have compiler in it's package.json.
+const entryPoints = getEntryPoints({
+  cwd: process.cwd(),
+});
 
-For example, to support `*.ts` and `*.tsx` implicit extensions in globally installed `rev-dep`, you have to also install globally `typescript` package (see [source](https://github.com/sverweij/dependency-cruiser/blob/96e34d0cf158034f2b7c8cafe9cec72dd74d8c45/src/extract/transpile/typescript-wrap.js))
+console.log(entryPoints);
+```
 
 ## CLI reference
 
@@ -133,7 +377,6 @@ rev-dep resolve <filePath> [entryPoints...] [options]
 
 - `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
 - `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
-- `-rr --reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
 - `-i --include <globs...>` - A list of globs to determine files included in entry points search (_optional_)
 - `-e --exclude <globs...>` - A list of globs to determine files excluded in entry points search (_optional_)
 - `-cs, --compactSummary` - print a compact summary of reverse resolution with a count of found paths (_optional_)
@@ -153,7 +396,6 @@ rev-dep entry-points [options]
 
 - `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
 - `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
-- `-rr --reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
 - `-i --include <globs...>` - A list of globs to determine files included in entry points search (_optional_)
 - `-e --exclude <globs...>` - A list of globs to determine files excluded in entry points search (_optional_)
 - `-pdc, --printDependenciesCount` - print count of entry point dependencies (_optional_)
@@ -177,7 +419,6 @@ rev-dep files <entryPoint> [options]
 
 - `-wc, --webpackConfig <path>` - path to webpack config to enable webpack aliases support (_optional_)
 - `--cwd <path>` - path to a directory that should be used as a resolution root (_optional_)
-- `-rr --reexportRewire <value>` - resolve actual dependencies for "export \* from" statements (_optional_)
 - `-c, --count` - print only count of entry point dependencies (_optional_)
 
 ### Command `docs`
@@ -199,6 +440,59 @@ rev-dep docs <outputPath> [options]
 - `-hl, --headerLevel <value>` - Initial header level (_optional_)
 <!-- cli-docs-end -->
 
+## Export from problem
+
+`rev-dep` attempts to also solve `export * from` by a babel plugin that can be used as follows
+
+```js
+// babel.config.js
+module.exports = {
+  plugins: [
+    'rev-dep/babel'
+  ]
+};
+```
+
+The plugins is currently **experimental** and might not work for all codebases!
+
+It helps by rewiring paths to re-exported modules
+
+```ts
+// file.ts
+import { add } from "./utils";
+
+// utils/index.ts
+
+export * from "./math";
+export * from "./otherModule";
+export * from "./anotherModule";
+
+// utils/math.ts
+
+export const add = () => {};
+```
+
+And for `file.ts` it would rewire the import like this
+
+```ts
+// file.ts
+import { add } from "./utils/math";
+```
+
+So as a result, we don't implicitly require `./otherModule` and `./anotherModule` which we will not use anyway
+
+### Benefits
+
+I don't have solid evidence for this, but I think it reduced RAM usage of the dev server I worked with (_blitz.js_). It crashed less often due to reaching heap size limit.
+
+But for sure it reduced bundle size, _slightly_, but still 😀
+
+It all depends on the the project dependencies structure.
+
+By using the babel plugin you will reduce a risk of problems like implicitly importing `front-end` modules on the `server` or similar while still being able to benefit from short import paths.
+
+Once I got an incident that, after a rebase with main branch, my project stopped compiling due to the problem caused by `export * from`. I spend a few hours debugging that, very frustrating.
+
 ## Contributing
 
 Project is open to contributions, just rise an issue if you have some ideas about features or you noticed a bug. After discussion we can approach implementation :)
@@ -207,16 +501,20 @@ Project is open to contributions, just rise an issue if you have some ideas abou
 
 1. Clone repo
 2. Install deps using `yarn`
-3. Run tests using `yarn test --watch`
+3. Run `yarn build:watch`
 4. Code!
 
-For testing purpose you can install CLI tool from the file system using
+For testing purpose use
+
+`yarn dev [command] --cwd path/to/some/codebase`
+
+or you can install CLI tool from the file system using
 
-`yarn global add file:ABSOLUTE_PATH_TO_REPO`
+`yarn global add $PWD`
 
-or just
+and then just run
 
-`yarn global add file:$(echo $PWD)`
+`rev-dep`
 
 ## Made with 🧠 by [@jayu](https://github.com/jayu)
 

package/dist/cli/entryPoints/index.js

@@ -10,7 +10,7 @@ function createEntryPoints(program) {
         .description('Print list of entry points in current directory')
         .option(...commonOptions_1.webpackConfigOption)
         .option(...commonOptions_1.cwdOption)
-        .option(...commonOptions_1.reexportRewireOption)
+        // .option(...reexportRewireOption)
         .option(...commonOptions_1.includeOption)
         .option(...commonOptions_1.excludeOption)
         .option('-pdc, --printDependenciesCount', 'print count of entry point dependencies', false)

package/dist/cli/files/index.js

@@ -11,7 +11,7 @@ function createFiles(program) {
     })
         .option(...commonOptions_1.webpackConfigOption)
         .option(...commonOptions_1.cwdOption)
-        .option(...commonOptions_1.reexportRewireOption)
+        // .option(...reexportRewireOption)
         .option('-c, --count', 'print only count of entry point dependencies', false)
         .action(async (entryPoint, data) => {
         const { webpackConfig: webpackConfigPath, cwd, count } = data;

package/dist/cli/resolve/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const find_1 = require("../../lib/find");
+const resolve_1 = require("../../lib/resolve");
 const formatResults_1 = require("./formatResults");
 const utils_1 = require("../../lib/utils");
 const commonOptions_1 = require("../commonOptions");
@@ -13,16 +13,15 @@ function createResolve(program) {
     })
         .option(...commonOptions_1.webpackConfigOption)
         .option(...commonOptions_1.cwdOption)
-        .option(...commonOptions_1.reexportRewireOption)
+        // .option(...reexportRewireOption)
         .option(...commonOptions_1.includeOption)
         .option(...commonOptions_1.excludeOption)
         .option('-cs, --compactSummary', 'print a compact summary of reverse resolution with a count of found paths')
         .option('-a, --all', 'finds all paths combination of a given dependency. Might work very slow or crash for some projects due to heavy usage of RAM', false)
         .action(async (filePath, entryPoints, data) => {
         const { compactSummary, webpackConfig, all, cwd, exclude, include } = data;
-        const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)(entryPoints);
-        const [results, resolveEntryPoints] = await (0, find_1.resolve)({
-            entryPoints: sanitizedEntryPoints,
+        const [results, resolveEntryPoints] = await (0, resolve_1.resolve)({
+            entryPoints,
             filePath,
             webpackConfig,
             all,

package/dist/lib/find.js

@@ -24,7 +24,8 @@ const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd
     let deps, entryPoints;
     if (_entryPoints.length > 0) {
         entryPoints = _entryPoints;
-        deps = await (0, getDepsTree_1.getDepsTree)(cwd, entryPoints, webpackConfig);
+        const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)(entryPoints);
+        deps = await (0, getDepsTree_1.getDepsTree)(cwd, sanitizedEntryPoints, webpackConfig);
     }
     else {
         ;

package/dist/lib/resolve.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolve = void 0;
+const buildDepsGraph_1 = require("./buildDepsGraph");
+const getDepsTree_1 = require("./getDepsTree");
+const getEntryPoints_1 = require("./getEntryPoints");
+const utils_1 = require("./utils");
+const resolvePathsToRoot = (node, all = false, resolvedPaths = [[]]) => {
+    const newPaths = resolvedPaths.map((resolvedPath) => [
+        node.path,
+        ...resolvedPath
+    ]);
+    if (node.parents.length === 0) {
+        return newPaths;
+    }
+    if (all) {
+        return node.parents
+            .map((parentPath) => resolvePathsToRoot(parentPath, all, newPaths))
+            .flat(1);
+    }
+    return resolvePathsToRoot(node.parents[0], false, newPaths);
+};
+const resolve = async ({ entryPoints: _entryPoints, filePath, webpackConfig, cwd = process.cwd(), all, include, exclude }) => {
+    let deps, entryPoints;
+    if (_entryPoints.length > 0) {
+        entryPoints = _entryPoints;
+        const sanitizedEntryPoints = (0, utils_1.sanitizeUserEntryPoints)(entryPoints);
+        deps = await (0, getDepsTree_1.getDepsTree)(cwd, sanitizedEntryPoints, webpackConfig);
+    }
+    else {
+        ;
+        [entryPoints, deps] = await (0, getEntryPoints_1.getEntryPoints)({ cwd, exclude, include });
+    }
+    const cleanedEntryPoints = entryPoints.map(utils_1.removeInitialDot);
+    const cleanedFilePath = (0, utils_1.removeInitialDot)(filePath);
+    const forest = cleanedEntryPoints.map((0, buildDepsGraph_1.buildGraphDpdm)(deps, cleanedFilePath));
+    const resolvedPaths = forest.reduce((allPaths, [_, fileNode]) => {
+        if (!fileNode) {
+            return [...allPaths, []];
+        }
+        const pathsForTree = resolvePathsToRoot(fileNode, all);
+        return [...allPaths, pathsForTree];
+    }, []);
+    return [resolvedPaths, entryPoints];
+};
+exports.resolve = resolve;

package/dist/module.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntryPoints = exports.resolve = void 0;
+var resolve_1 = require("./lib/resolve");
+Object.defineProperty(exports, "resolve", { enumerable: true, get: function () { return resolve_1.resolve; } });
+var getEntryPoints_1 = require("./lib/getEntryPoints");
+Object.defineProperty(exports, "getEntryPoints", { enumerable: true, get: function () { return getEntryPoints_1.getEntryPoints; } });

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "rev-dep",
-  "version": "1.0.0-alpha.3",
-  "description": "Reverse dependency resolution tool built with dependency-cruiser",
-  "main": "lib/find.js",
+  "version": "1.0.0-alpha.6",
+  "description": "Dependency debugging tool for JavaScript and TypeScript projects",
+  "main": "dist/module.js",
   "bin": "bin.js",
   "files": [
     "dist/**",
@@ -59,5 +59,18 @@
     "prettier": "^2.1.2",
     "release-it": "^14.2.1",
     "typescript": "^4.6.2"
-  }
+  },
+  "keywords": [
+    "dependencies",
+    "deps",
+    "dependency graph",
+    "dependency debugging",
+    "entry points",
+    "dependency resolution",
+    "reverse dependency resolution",
+    "dependency tree",
+    "import path",
+    "resolution path",
+    "dependency optimization"
+  ]
 }