@ecoma-io/archkeep 0.13.0

package/index.mjs

@@ -0,0 +1,85 @@
+/**
+ * The engine entry — what a consumer gets from `import "@ecoma-io/archkeep"`.
+ * Nx is one caller of this graph, not the only one: the CLI (`cli.mjs`) and
+ * the language server (`lsp.mjs`) both work from these same primitives, and
+ * this file is the surface a future integration (Bazel, Turborepo, a CI
+ * action) would import instead of reaching into `src/` directly. The Nx
+ * plugin itself lives at the `./nx` subpath (`nx.mjs`) — the one module
+ * `nx.json → plugins` is allowed to name — precisely so that loading the
+ * engine never pulls Nx's own startup path in for free.
+ *
+ * What's re-exported here is discovery (read a real workspace: the project
+ * graph, tracked files, per-file analysis) and judgment (evaluate that
+ * workspace against a boundary config) — the two halves `cli.mjs` composes.
+ * Nothing under `src/rules/`, `src/analysis/`, or `src/report/` is duplicated
+ * here; this module only re-exports their public functions. The one
+ * exception is `createDependencies` below, which is not a re-export and
+ * holds one line of logic: a guard against exactly this file being
+ * misregistered as the Nx plugin face that `./nx` (`nx.mjs`) alone is meant
+ * to be.
+ */
+export {
+  annotateMFERemotes,
+  annotatePackageFacts,
+  analyzeWorkspace,
+  createWorkspace,
+  declaredPackages,
+  environmentForTree,
+  findWorkspaceRoot,
+  listTrackedFiles,
+  packageEntryPoints,
+  projectIsMFERemote,
+  runProcess,
+  selectFiles,
+} from "./src/workspace.mjs";
+
+export { nxProvider, readProjectGraph } from "./src/providers/nx.mjs";
+
+export {
+  analyzeFile,
+  analyzerFor,
+  LANGUAGE_BY_EXTENSION,
+  languageOf,
+} from "./src/analysis/analyze.mjs";
+
+export {
+  findBoundaryConfigViolations,
+  loadBoundaryConfig,
+  loadBoundaryConfigFile,
+  suppressionCovers,
+} from "./src/config.mjs";
+
+export { evaluate, MESSAGE_IDS, MESSAGES, renderMessage } from "./src/rules/index.mjs";
+
+/**
+ * The one export this file adds beyond a re-export, and it exists to fail
+ * loudly rather than to do anything.
+ *
+ * Measured against nx 23.1.1 in this tree: a consumer writing
+ * `"plugins": ["@ecoma-io/archkeep"]` in `nx.json` — the bare package name,
+ * missing the `/nx` — resolves to this file. Before this export existed the
+ * file had neither `name` nor `createDependencies`, and Nx accepted that
+ * silently: `nx graph` exited 0, printed no warning, and computed zero
+ * polyglot edges, indistinguishable from a workspace with nothing to find.
+ * That is the exact failure this project exists to refuse, one layer above
+ * every check it ships: a misregistration that reads as a clean graph.
+ *
+ * Exporting `name` alongside this was tried and measured too, and dropped:
+ * with only `name` added (still no `createDependencies`) Nx's behaviour did
+ * not change at all — same exit 0, same silence, same empty graph — so it
+ * buys nothing. `createDependencies` throwing is what Nx actually surfaces:
+ * with this export in place, `nx graph` prints the message below to the
+ * terminal, naming the fix. `name` is left for `./nx` alone to export, which
+ * keeps this file from looking like a working plugin face — it is the
+ * engine, not the face; `AGENTS.md` ("Layout, and what each layer may know")
+ * says which module carries which.
+ *
+ * @throws {Error} named `archkeep: registered as the engine entry`, always.
+ */
+export function createDependencies() {
+  throw new Error(
+    "archkeep: registered as the engine entry, not the Nx plugin face — nx.json named " +
+      '"@ecoma-io/archkeep" instead of "@ecoma-io/archkeep/nx". Change the `plugin` value in ' +
+      'nx.json to "@ecoma-io/archkeep/nx" (README.md, "Installing it").',
+  );
+}

package/lsp.mjs

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+/**
+ * Language-server entry — the stdio wiring, and nothing else.
+ *
+ * Everything the server decides lives in `src/lsp/`; this file only turns a
+ * byte stream into messages and back. The split is what lets the protocol
+ * conversation be driven in-process by a test (`src/lsp/server.test.mjs`) while
+ * `src/lsp.integration.test.mjs` still drives this executable over real pipes,
+ * because framing, stream wiring and the exit contract only hold together in a
+ * real process.
+ *
+ * Framing is the LSP base protocol: `Content-Length: <n>\r\n\r\n<utf8 json>`.
+ * Implemented in `src/lsp/protocol.mjs` rather than pulled from a dependency
+ * because it is a fixed external contract of about forty lines, and because
+ * this tool stays on Node built-ins (AGENTS.md).
+ *
+ * **stdout carries the protocol and nothing else.** Every log line goes to
+ * stderr: one stray `console.log` here would be read by the client as a
+ * malformed frame and desynchronise the stream for the rest of the session.
+ */
+import { isProgramEntry } from "./src/entry-point.mjs";
+import { encodeMessage, frameMessages } from "./src/lsp/protocol.mjs";
+import { createServer } from "./src/lsp/server.mjs";
+
+/**
+ * Ends the process, but not before the client has the bytes.
+ *
+ * `process.exit()` discards whatever is still queued on a pipe, and the thing
+ * most often still queued is the reply to `shutdown` — the message that tells
+ * the client the session ended cleanly. An empty write is ordered behind every
+ * earlier one, so its callback runs only once they have all reached the OS.
+ * `exitCode` is set first so that a stream which never drains still ends the
+ * process with the right code instead of a silent 0.
+ */
+function exitAfterFlush(output, code) {
+  process.exitCode = code;
+  output.write("", () => process.exit(code));
+}
+
+/** Wires a server to a pair of streams and returns it. */
+export function serve(input = process.stdin, output = process.stdout, onExit = null) {
+  const send = (message) => output.write(encodeMessage(message));
+  const exit = onExit ?? ((code) => exitAfterFlush(output, code));
+  const log = (text) => process.stderr.write(`${text}\n`);
+  const server = createServer({ send, exit, log });
+
+  /** @type {Buffer} */
+  let pending = Buffer.alloc(0);
+  // No encoding is ever set on `input`, so a data chunk is always a Buffer.
+  input.on("data", (/** @type {Buffer} */ chunk) => {
+    const framed = frameMessages(Buffer.concat([pending, chunk]));
+    // An implausible `Content-Length` is a poisoned stream, not a client that
+    // will send more bytes — see `MAX_CONTENT_LENGTH` in `./src/lsp/protocol.mjs`.
+    // The session is closed loudly (a log line naming the length, and a
+    // non-zero exit) rather than held open forever on a body that will never
+    // arrive: a frame that cannot be framed must never look like a clean,
+    // empty conversation.
+    if (framed.protocolError !== undefined) {
+      pending = Buffer.alloc(0);
+      log(framed.protocolError);
+      // Exit 2 is deliberate, and not the CLI's usage-error 2 — that is a
+      // different process (`docs/reference/exit-codes.md`). The server's own
+      // contract (`./src/lsp/server.mjs`) ends a session 0 after a clean
+      // `shutdown` and 1 when the pipe closed without one; a poisoned protocol
+      // stream is neither, and sharing either code would read as a clean or
+      // merely-dirty shutdown to whatever supervised the process.
+      exit(2);
+      return;
+    }
+    pending = framed.rest;
+    for (const message of framed.messages) server.handle(message);
+  });
+  // A client that closed the pipe without saying `exit` did not shut the server
+  // down; reporting that as a clean stop would hide a crashed editor.
+  input.on("end", () => server.handle({ jsonrpc: "2.0", method: "exit" }));
+  return server;
+}
+
+if (isProgramEntry(import.meta.url)) {
+  serve();
+}

package/nx.mjs

@@ -0,0 +1,24 @@
+/**
+ * Nx plugin entry — the module `nx.json → plugins` names, reached through this
+ * package's `./nx` subpath export, and the only surface Nx itself is allowed
+ * to know about.
+ *
+ * It holds no logic on purpose. Nx loads this file on every graph computation,
+ * including on machines running a single unrelated target, so what it imports
+ * is what every `nx` invocation pays for. Keeping the entry a re-export means
+ * the rule engine, the CLI, and the language server can grow under `src/`
+ * without any of it being dragged into Nx's own startup path — and it keeps
+ * `CreateDependenciesContext`, the shape most likely to move under an Nx
+ * upgrade, touching exactly one module (`src/graph/create-dependencies.mjs`).
+ *
+ * The plugin's own contract with Nx is the two names below: `name`, and a
+ * `createDependencies` returning raw dependency records. The root entry
+ * (`index.mjs`) is the engine those same primitives serve to the CLI and the
+ * language server — Nx is one caller of the graph, not the only one.
+ */
+export {
+  createDependencies,
+  resolvePolyglotDependencies,
+} from "./src/graph/create-dependencies.mjs";
+
+export const name = "archkeep";

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@ecoma-io/archkeep",
+  "version": "0.13.0",
+  "description": "Architecture enforcement for polyglot repositories — dependency graphs and module boundaries for Go, Rust, Python, TypeScript, JavaScript and Vue",
+  "keywords": [
+    "architecture",
+    "enforcement",
+    "dependency-graph",
+    "monorepo",
+    "module-boundaries",
+    "polyglot",
+    "static-analysis",
+    "language-server",
+    "nx",
+    "nx-plugin",
+    "golang",
+    "rust",
+    "python",
+    "typescript"
+  ],
+  "type": "module",
+  "license": "Apache-2.0",
+  "bin": {
+    "archkeep": "cli.mjs",
+    "archkeep-lsp": "lsp.mjs"
+  },
+  "main": "index.mjs",
+  "exports": {
+    ".": "./index.mjs",
+    "./nx": "./nx.mjs",
+    "./presets/*.json": "./presets/*.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "index.mjs",
+    "nx.mjs",
+    "cli.mjs",
+    "lsp.mjs",
+    "src/",
+    "!src/**/*.test.mjs",
+    "!src/conformance/",
+    "!src/custom-rules/wasm-fixture.mjs",
+    "!src/report/envelope-shape.json",
+    "!src/custom-rules/evidence-golden.json",
+    "presets/",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "smol-toml": "1.8.0"
+  },
+  "peerDependencies": {
+    "@nx/eslint-plugin": ">=21",
+    "nx": ">=21",
+    "typescript": ">=5 <7",
+    "vue": ">=3"
+  },
+  "peerDependenciesMeta": {
+    "@nx/eslint-plugin": {
+      "optional": true
+    },
+    "nx": {
+      "optional": true
+    },
+    "vue": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "homepage": "https://github.com/ecoma-io/archkeep/tree/main/packages/archkeep#readme",
+  "bugs": {
+    "url": "https://github.com/ecoma-io/archkeep/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ecoma-io/archkeep.git",
+    "directory": "packages/archkeep"
+  }
+}

package/presets/clean-architecture.json

@@ -0,0 +1,78 @@
+{
+  "version": 1,
+  "profiles": [
+    {
+      "name": "clean-architecture",
+      "block": {
+        "depConstraints": [
+          {
+            "sourceTag": "layer:entities",
+            "onlyDependOnLibsWithTags": ["layer:entities"],
+            "description": "Enterprise business rules sit at the centre: entities depend on nothing outside their own layer.",
+            "remediation": "Move the collaborator into layer:entities, or invert the dependency so the outer layer depends on the entity."
+          },
+          {
+            "sourceTag": "layer:use-cases",
+            "onlyDependOnLibsWithTags": ["layer:use-cases", "layer:entities"],
+            "description": "Application business rules may reach inward to entities and sideways within their own layer, never outward.",
+            "remediation": "Declare a port in layer:use-cases and let layer:interface-adapters implement it."
+          },
+          {
+            "sourceTag": "layer:interface-adapters",
+            "onlyDependOnLibsWithTags": [
+              "layer:interface-adapters",
+              "layer:use-cases",
+              "layer:entities"
+            ],
+            "description": "Controllers, presenters and gateways convert between the outside world and the use cases; they never depend on a framework project.",
+            "remediation": "Keep the framework detail in layer:frameworks and pass it in through the adapter's own interface."
+          },
+          {
+            "sourceTag": "layer:frameworks",
+            "onlyDependOnLibsWithTags": [
+              "layer:frameworks",
+              "layer:interface-adapters",
+              "layer:use-cases",
+              "layer:entities"
+            ],
+            "description": "Drivers, delivery mechanisms and the composition root — the only layer allowed to know every other one.",
+            "remediation": "Nothing inside this layer may be imported from a project tagged with an inner layer; move the shared piece inward instead."
+          }
+        ],
+        "moduleBoundaryOptions": {
+          "allow": [],
+          "buildTargets": ["build"],
+          "enforceBuildableLibDependency": false,
+          "allowCircularSelfDependency": false,
+          "checkDynamicDependenciesExceptions": [],
+          "ignoredCircularDependencies": [],
+          "banTransitiveDependencies": false,
+          "checkNestedExternalImports": false
+        }
+      }
+    },
+    {
+      "name": "clean-architecture-pure-core",
+      "base": "clean-architecture",
+      "block": {
+        "depConstraints": [
+          {
+            "sourceTag": "layer:entities",
+            "bannedExternalImports": ["*"],
+            "description": "The Dependency Rule applied to third-party code: entities import no package outside the workspace, Node built-ins included.",
+            "remediation": "Wrap the package behind an interface owned by layer:entities and implement it in an outer layer."
+          },
+          {
+            "sourceTag": "layer:use-cases",
+            "bannedExternalImports": ["*"],
+            "description": "Application business rules stay framework-free for the same reason entities do.",
+            "remediation": "Declare a port for the capability and let layer:interface-adapters bring the package in."
+          }
+        ],
+        "moduleBoundaryOptions": {
+          "checkNestedExternalImports": true
+        }
+      }
+    }
+  ]
+}

package/presets/ddd-bounded-contexts.json

@@ -0,0 +1,88 @@
+{
+  "version": 1,
+  "profiles": [
+    {
+      "name": "ddd-bounded-contexts",
+      "block": {
+        "depConstraints": [
+          {
+            "sourceTag": "layer:domain",
+            "onlyDependOnLibsWithTags": ["layer:domain"],
+            "description": "The model of one bounded context. It names no contract, no service and no store — only model.",
+            "remediation": "Move the collaborator into layer:domain, or express the need as an interface the application layer satisfies."
+          },
+          {
+            "sourceTag": "layer:application",
+            "onlyDependOnLibsWithTags": [
+              "layer:application",
+              "layer:domain",
+              "layer:published-language"
+            ],
+            "description": "Use cases orchestrate the model and speak to other contexts through their published language, never through their model.",
+            "remediation": "Translate at the boundary: consume the other context's layer:published-language project instead of its layer:domain one."
+          },
+          {
+            "sourceTag": "layer:infrastructure",
+            "onlyDependOnLibsWithTags": [
+              "layer:infrastructure",
+              "layer:application",
+              "layer:domain",
+              "layer:published-language"
+            ],
+            "description": "Persistence, messaging and the anti-corruption layer — where another context's shape is allowed to arrive and be translated.",
+            "remediation": "Nothing inside the model or the use cases may import this layer; invert the dependency with an interface they own."
+          },
+          {
+            "sourceTag": "layer:published-language",
+            "onlyDependOnLibsWithTags": ["layer:published-language"],
+            "description": "Integration events and contracts are what other contexts are allowed to couple to, so they may couple to nothing else.",
+            "remediation": "A contract that needs a model type is leaking the model; restate the type in the contract project."
+          }
+        ],
+        "moduleBoundaryOptions": {
+          "allow": [],
+          "buildTargets": ["build"],
+          "enforceBuildableLibDependency": false,
+          "allowCircularSelfDependency": false,
+          "checkDynamicDependenciesExceptions": [],
+          "ignoredCircularDependencies": [],
+          "banTransitiveDependencies": false,
+          "checkNestedExternalImports": false
+        }
+      }
+    },
+    {
+      "name": "ddd-bounded-contexts-isolated",
+      "base": "ddd-bounded-contexts",
+      "block": {
+        "depConstraints": [
+          {
+            "sourceTag": "share:private",
+            "notDependOnLibsWithTags": ["share:private"],
+            "description": "Whatever a context keeps to itself is reachable from nothing but itself. Valid only where one project is one bounded context — see the presets page before selecting this profile.",
+            "remediation": "Publish what the other context needs as a share:published contract, and depend on that."
+          }
+        ],
+        "moduleBoundaryOptions": {}
+      }
+    },
+    {
+      "name": "ddd-bounded-contexts-partitioned",
+      "base": "ddd-bounded-contexts",
+      "block": {
+        "fitness": [
+          {
+            "name": "context-isolation",
+            "match": ["tag:layer:domain", "tag:layer:application", "tag:layer:infrastructure"],
+            "condition": {
+              "type": "tag-axis-isolation",
+              "axis": "context",
+              "exempt": ["tag:layer:published-language"]
+            },
+            "reason": "What ddd-bounded-contexts-isolated means, without its one-project-per-context assumption. That profile forbids share:private depending on share:private, which reports two private projects of the SAME context depending on each other. This one asks the question the style actually asks — does this edge leave its context? — by reading the context: axis relative to the source, so a context may span as many projects as it needs while still reaching another context only through a layer:published-language contract. It matches on the three layer tags the base profile's own rows key on, never on a second axis a workspace might not carry: a project matching none of them is already reported by those rows, so this function can never quietly select nothing. Tag every project with a context: value; a matched project carrying none is reported as unjudgeable rather than waved through."
+          }
+        ]
+      }
+    }
+  ]
+}

package/presets/hexagonal.json

@@ -0,0 +1,68 @@
+{
+  "version": 1,
+  "profiles": [
+    {
+      "name": "hexagonal",
+      "block": {
+        "depConstraints": [
+          {
+            "sourceTag": "layer:domain",
+            "onlyDependOnLibsWithTags": ["layer:domain"],
+            "description": "The inside of the hexagon. The domain knows neither its ports nor anything that plugs into them.",
+            "remediation": "Move the collaborator into layer:domain, or express the need as a port and let an adapter satisfy it."
+          },
+          {
+            "sourceTag": "layer:ports",
+            "onlyDependOnLibsWithTags": ["layer:ports", "layer:domain"],
+            "description": "A port is the domain's own statement of what it needs or offers, so it may name domain types and other ports.",
+            "remediation": "A port that needs an adapter's type is describing an implementation; keep the type in layer:domain instead."
+          },
+          {
+            "sourceTag": "layer:adapters",
+            "onlyDependOnLibsWithTags": ["layer:ports", "layer:domain"],
+            "description": "An adapter implements a port. It may not depend on another adapter — two adapters that talk to each other have made a driven side into a driving one.",
+            "remediation": "Route the collaboration through a port, or promote the shared piece into layer:domain."
+          },
+          {
+            "sourceTag": "layer:app",
+            "onlyDependOnLibsWithTags": [
+              "layer:app",
+              "layer:adapters",
+              "layer:ports",
+              "layer:domain"
+            ],
+            "description": "The composition root: the one place allowed to name a concrete adapter and wire it to a port.",
+            "remediation": "Nothing inside the hexagon may import this layer; move the wiring outward rather than the dependency inward."
+          }
+        ],
+        "moduleBoundaryOptions": {
+          "allow": [],
+          "buildTargets": ["build"],
+          "enforceBuildableLibDependency": false,
+          "allowCircularSelfDependency": false,
+          "checkDynamicDependenciesExceptions": [],
+          "ignoredCircularDependencies": [],
+          "banTransitiveDependencies": false,
+          "checkNestedExternalImports": false
+        }
+      }
+    },
+    {
+      "name": "hexagonal-pure-domain",
+      "base": "hexagonal",
+      "block": {
+        "depConstraints": [
+          {
+            "sourceTag": "layer:domain",
+            "bannedExternalImports": ["*"],
+            "description": "The hexagon's inside takes no third-party package at all, Node built-ins included — every capability arrives through a port.",
+            "remediation": "Declare a port for the capability and implement it in layer:adapters, where the package belongs."
+          }
+        ],
+        "moduleBoundaryOptions": {
+          "checkNestedExternalImports": true
+        }
+      }
+    }
+  ]
+}

package/presets/layered.json

@@ -0,0 +1,92 @@
+{
+  "version": 1,
+  "profiles": [
+    {
+      "name": "layered-strict",
+      "block": {
+        "depConstraints": [
+          {
+            "sourceTag": "tier:presentation",
+            "onlyDependOnLibsWithTags": ["tier:presentation", "tier:application"],
+            "description": "Strict layering: presentation may reach its own tier and application, the tier immediately below it, and nothing else. A downward edge that skips a tier is a finding here.",
+            "remediation": "Route the call through application rather than reaching past it, or move the collaborator up to the tier that is allowed to see it."
+          },
+          {
+            "sourceTag": "tier:application",
+            "onlyDependOnLibsWithTags": ["tier:application", "tier:domain"],
+            "description": "Strict layering: application may reach its own tier and domain, the tier immediately below it, and nothing else. A downward edge that skips a tier is a finding here.",
+            "remediation": "Route the call through domain rather than reaching past it, or move the collaborator up to the tier that is allowed to see it."
+          },
+          {
+            "sourceTag": "tier:domain",
+            "onlyDependOnLibsWithTags": ["tier:domain", "tier:infrastructure"],
+            "description": "Strict layering: domain may reach its own tier and infrastructure, the tier immediately below it, and nothing else. There is nothing beneath infrastructure, so every finding this row can produce is an upward edge.",
+            "remediation": "Nothing above may be imported from here; invert the dependency, or move the shared piece down into infrastructure where both sides may see it."
+          },
+          {
+            "sourceTag": "tier:infrastructure",
+            "onlyDependOnLibsWithTags": ["tier:infrastructure"],
+            "description": "The bottom tier. It may reach its own tier and nothing else, because there is nothing beneath it — so every finding this row can produce is an upward edge.",
+            "remediation": "Nothing above may be imported from here; invert the dependency, or move the shared piece down into this tier where both sides may see it."
+          }
+        ],
+        "moduleBoundaryOptions": {
+          "allow": [],
+          "buildTargets": ["build"],
+          "enforceBuildableLibDependency": false,
+          "allowCircularSelfDependency": false,
+          "checkDynamicDependenciesExceptions": [],
+          "ignoredCircularDependencies": [],
+          "banTransitiveDependencies": false,
+          "checkNestedExternalImports": false
+        }
+      }
+    },
+    {
+      "name": "layered-relaxed",
+      "block": {
+        "depConstraints": [
+          {
+            "sourceTag": "tier:presentation",
+            "onlyDependOnLibsWithTags": [
+              "tier:presentation",
+              "tier:application",
+              "tier:domain",
+              "tier:infrastructure"
+            ],
+            "description": "Relaxed layering: presentation may reach its own tier and every tier beneath it, at any depth.",
+            "remediation": "An upward edge is the violation here; invert the dependency, or move the shared piece down to a tier both sides may see."
+          },
+          {
+            "sourceTag": "tier:application",
+            "onlyDependOnLibsWithTags": ["tier:application", "tier:domain", "tier:infrastructure"],
+            "description": "Relaxed layering: application may reach its own tier and every tier beneath it, at any depth.",
+            "remediation": "An upward edge is the violation here; invert the dependency, or move the shared piece down to a tier both sides may see."
+          },
+          {
+            "sourceTag": "tier:domain",
+            "onlyDependOnLibsWithTags": ["tier:domain", "tier:infrastructure"],
+            "description": "Relaxed layering: domain may reach its own tier and every tier beneath it, at any depth.",
+            "remediation": "An upward edge is the violation here; invert the dependency, or move the shared piece down to a tier both sides may see."
+          },
+          {
+            "sourceTag": "tier:infrastructure",
+            "onlyDependOnLibsWithTags": ["tier:infrastructure"],
+            "description": "The bottom tier. It may reach its own tier and nothing else, because there is nothing beneath it — so every finding this row can produce is an upward edge.",
+            "remediation": "Nothing above may be imported from here; invert the dependency, or move the shared piece down into this tier where both sides may see it."
+          }
+        ],
+        "moduleBoundaryOptions": {
+          "allow": [],
+          "buildTargets": ["build"],
+          "enforceBuildableLibDependency": false,
+          "allowCircularSelfDependency": false,
+          "checkDynamicDependenciesExceptions": [],
+          "ignoredCircularDependencies": [],
+          "banTransitiveDependencies": false,
+          "checkNestedExternalImports": false
+        }
+      }
+    }
+  ]
+}