@noctcore/eslint-plugin-architecture 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,12 +1,20 @@
 // src/configs/recommended.ts
 var recommended = {
+  "noctcore-architecture/barrel-purity": "error",
+  // Ships OFF: this rule does nothing until you name the source globs that must
+  // be tested (there is no universal "everything needs a test" default). Enable
+  // it with your own `include`, e.g.
+  //   'noctcore-architecture/colocated-test-required': ['error', { include: ['**/use*.ts', '**/*.service.ts'] }]
+  "noctcore-architecture/colocated-test-required": "off",
   "noctcore-architecture/component-folder-structure": "error",
+  "noctcore-architecture/filename-matches-export": "error",
   "noctcore-architecture/index-must-reexport-default": "error",
+  "noctcore-architecture/max-import-depth": "error",
   "noctcore-architecture/no-cross-feature-imports": "error"
 };
 
-// src/rules/component-folder-structure.ts
-import path2 from "path";
+// src/rules/barrel-purity.ts
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
 
 // src/createRule.ts
 import { makeCreateRule } from "@noctcore/eslint-utils";
@@ -98,8 +106,154 @@ function readDirSafe(dir) {
   }
 }
 
+// src/rules/barrel-purity.ts
+var RULE_NAME = "barrel-purity";
+var DEFAULT_ALLOW = [];
+var BARREL_BASENAME = /^index\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/;
+var optionSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    allow: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+function impurityOf(stmt) {
+  switch (stmt.type) {
+    case AST_NODE_TYPES.ImportDeclaration:
+      return stmt.specifiers.length === 0 ? "a side-effect import" : null;
+    case AST_NODE_TYPES.ExportAllDeclaration:
+      return null;
+    case AST_NODE_TYPES.ExportNamedDeclaration:
+      if (stmt.source !== null) {
+        return null;
+      }
+      if (stmt.declaration === null) {
+        return null;
+      }
+      return "a local declaration";
+    case AST_NODE_TYPES.ExportDefaultDeclaration:
+      return stmt.declaration.type === AST_NODE_TYPES.Identifier ? null : "a default-exported value";
+    case AST_NODE_TYPES.ExpressionStatement:
+      return "a side-effect statement";
+    default:
+      return "non-re-export code";
+  }
+}
+var barrelPurityRule = createRule({
+  name: RULE_NAME,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A barrel (`index.ts` / `index.tsx`) must contain only re-exports \u2014 never local declarations, side effects, or default-exported values."
+    },
+    schema: [optionSchema],
+    messages: {
+      impureBarrel: "A barrel must contain only re-exports; found {{kind}}. Move it into a sibling module and re-export it from here."
+    }
+  },
+  defaultOptions: [{ allow: [] }],
+  create(context, [options]) {
+    const allow = options.allow ?? DEFAULT_ALLOW;
+    const filename = context.filename;
+    if (!BARREL_BASENAME.test(getBasename(filename)) || isIgnoredPath(filename, allow)) {
+      return {};
+    }
+    return {
+      Program(node) {
+        for (const stmt of node.body) {
+          const kind = impurityOf(stmt);
+          if (kind !== null) {
+            context.report({ node: stmt, messageId: "impureBarrel", data: { kind } });
+          }
+        }
+      }
+    };
+  }
+});
+
+// src/rules/colocated-test-required.ts
+import { readdirSync as readdirSync2 } from "fs";
+import path2 from "path";
+var RULE_NAME2 = "colocated-test-required";
+var DEFAULT_INCLUDE = [];
+var DEFAULT_IGNORE = [];
+var TEST_SIBLING = /\.(test|spec)\.[^.]+$/;
+var optionSchema2 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    include: { type: "array", items: { type: "string" }, uniqueItems: true },
+    ignore: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+var dirCache = /* @__PURE__ */ new Map();
+function readDirCached(dir) {
+  const cached = dirCache.get(dir);
+  if (cached !== void 0) {
+    return cached;
+  }
+  let entries;
+  try {
+    entries = readdirSync2(dir);
+  } catch {
+    entries = [];
+  }
+  dirCache.set(dir, entries);
+  return entries;
+}
+function stemOf(basename) {
+  const ext = path2.extname(basename);
+  return ext === "" ? basename : basename.slice(0, -ext.length);
+}
+function hasColocatedTest(dir, stem) {
+  const prefix = `${stem}.`;
+  return readDirCached(dir).some(
+    (entry) => entry.startsWith(prefix) && TEST_SIBLING.test(entry)
+  );
+}
+var colocatedTestRequiredRule = createRule({
+  name: RULE_NAME2,
+  meta: {
+    type: "problem",
+    docs: {
+      description: "A source file matching an `include` glob must have a colocated `*.test.*` / `*.spec.*` sibling on disk. Off until `include` is configured."
+    },
+    schema: [optionSchema2],
+    messages: {
+      missingTest: "Source file `{{basename}}` has no colocated test. Add a sibling `{{stem}}.test.*` (or `.spec.*`) next to it."
+    }
+  },
+  defaultOptions: [{ include: [], ignore: [] }],
+  create(context, [options]) {
+    const include = options.include ?? DEFAULT_INCLUDE;
+    const ignore = options.ignore ?? DEFAULT_IGNORE;
+    const filename = context.filename;
+    if (include.length === 0 || !isIgnoredPath(filename, include)) {
+      return {};
+    }
+    const basename = getBasename(filename);
+    if (TEST_SIBLING.test(basename) || isIgnoredPath(filename, ignore)) {
+      return {};
+    }
+    const stem = stemOf(basename);
+    const dir = path2.dirname(filename);
+    return {
+      Program(node) {
+        if (!hasColocatedTest(dir, stem)) {
+          context.report({
+            node,
+            messageId: "missingTest",
+            data: { basename, stem }
+          });
+        }
+      }
+    };
+  }
+});
+
 // src/rules/component-folder-structure.ts
-var RULE_NAME = "component-folder-structure";
+import path3 from "path";
+var RULE_NAME3 = "component-folder-structure";
 var DEFAULT_COMPONENT_ROOT = "components";
 var DEFAULT_IGNORE_PATHS = ["**/ui/**"];
 var DEFAULT_REQUIRED_SIBLINGS = [
@@ -112,7 +266,7 @@ var DEFAULT_REQUIRED_SIBLINGS = [
 function resolveSibling(template, name) {
   return template.startsWith(".") ? `${name}${template}` : template;
 }
-var optionSchema = {
+var optionSchema3 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -122,13 +276,13 @@ var optionSchema = {
   }
 };
 var componentFolderStructureRule = createRule({
-  name: RULE_NAME,
+  name: RULE_NAME3,
   meta: {
     type: "problem",
     docs: {
       description: "A component `<Name>/<Name>.tsx` under `<componentRoot>/<feature>/...` must have its sibling set (`.hooks.ts`, `.types.ts`, `.stories.tsx`, `.test.tsx`, `index.ts`) present on disk."
     },
-    schema: [optionSchema],
+    schema: [optionSchema3],
     messages: {
       missingSiblings: "Component `{{name}}` is missing sibling file(s): {{missing}}. Every component folder must carry its hooks, types, stories, test, and index barrel."
     }
@@ -152,7 +306,7 @@ var componentFolderStructureRule = createRule({
       return {};
     }
     const name = getComponentName(filename);
-    const dir = path2.dirname(filename);
+    const dir = path3.dirname(filename);
     const required = siblingTemplates.map((template) => resolveSibling(template, name));
     const present = readDirSafe(dir);
     const missing = required.filter((sibling) => !present.has(sibling));
@@ -170,12 +324,164 @@ var componentFolderStructureRule = createRule({
   }
 });
 
+// src/rules/filename-matches-export.ts
+import path4 from "path";
+import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
+var RULE_NAME4 = "filename-matches-export";
+var DEFAULT_IGNORE2 = [];
+var VALID_IDENTIFIER = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+var optionSchema4 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    ignore: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+function stemOf2(filename) {
+  const basename = getBasename(filename);
+  const ext = path4.extname(basename);
+  return ext === "" ? basename : basename.slice(0, -ext.length);
+}
+function normalize(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]/g, "");
+}
+function namedExportId(decl) {
+  if (decl.declaration === null) {
+    return null;
+  }
+  const d = decl.declaration;
+  switch (d.type) {
+    case AST_NODE_TYPES2.FunctionDeclaration:
+    case AST_NODE_TYPES2.ClassDeclaration:
+      return d.id;
+    case AST_NODE_TYPES2.TSTypeAliasDeclaration:
+    case AST_NODE_TYPES2.TSInterfaceDeclaration:
+    case AST_NODE_TYPES2.TSEnumDeclaration:
+      return d.id;
+    case AST_NODE_TYPES2.VariableDeclaration: {
+      const only = d.declarations.length === 1 ? d.declarations[0] : void 0;
+      return only !== void 0 && only.id.type === AST_NODE_TYPES2.Identifier ? only.id : null;
+    }
+    default:
+      return null;
+  }
+}
+function defaultExportId(decl) {
+  const d = decl.declaration;
+  if ((d.type === AST_NODE_TYPES2.FunctionDeclaration || d.type === AST_NODE_TYPES2.ClassDeclaration) && d.id !== null) {
+    return d.id;
+  }
+  return d.type === AST_NODE_TYPES2.Identifier ? d : null;
+}
+function resolvePrimary(body) {
+  let hasDefault = false;
+  let defaultId = null;
+  const named = [];
+  for (const stmt of body) {
+    if (stmt.type === AST_NODE_TYPES2.ExportDefaultDeclaration) {
+      hasDefault = true;
+      defaultId = defaultExportId(stmt);
+    } else if (stmt.type === AST_NODE_TYPES2.ExportNamedDeclaration && stmt.source === null) {
+      const id = namedExportId(stmt);
+      if (id !== null) {
+        named.push(id);
+      } else if (stmt.declaration === null) {
+        for (const spec of stmt.specifiers) {
+          if (spec.exported.type === AST_NODE_TYPES2.Identifier) {
+            named.push(spec.exported);
+          }
+        }
+      }
+    }
+  }
+  if (hasDefault) {
+    return defaultId === null ? null : { name: defaultId.name, node: defaultId };
+  }
+  const only = named.length === 1 ? named[0] : void 0;
+  return only !== void 0 ? { name: only.name, node: only } : null;
+}
+function moduleVariable(sourceCode, name) {
+  const globalScope = sourceCode.scopeManager?.globalScope ?? null;
+  if (globalScope === null) {
+    return null;
+  }
+  const moduleScope = globalScope.childScopes[0] ?? globalScope;
+  return moduleScope.variables.find((v) => v.name === name) ?? null;
+}
+var IMPORT_DEF_NODES = /* @__PURE__ */ new Set([
+  AST_NODE_TYPES2.ImportSpecifier,
+  AST_NODE_TYPES2.ImportDefaultSpecifier,
+  AST_NODE_TYPES2.ImportNamespaceSpecifier
+]);
+function isImportBinding(variable) {
+  return variable.defs.some((def) => IMPORT_DEF_NODES.has(def.node.type));
+}
+var filenameMatchesExportRule = createRule({
+  name: RULE_NAME4,
+  meta: {
+    type: "suggestion",
+    hasSuggestions: true,
+    docs: {
+      description: "A file's basename must match its primary export (a default export, or the sole named export)."
+    },
+    schema: [optionSchema4],
+    messages: {
+      filenameMismatch: "File `{{basename}}` exports `{{name}}` as its primary export \u2014 the basename should match it (rename the file to `{{expected}}`, or the export).",
+      renameExport: "Rename the export to `{{expected}}` to match the filename."
+    }
+  },
+  defaultOptions: [{ ignore: [] }],
+  create(context, [options]) {
+    const ignore = options.ignore ?? DEFAULT_IGNORE2;
+    const filename = context.filename;
+    const stem = stemOf2(filename);
+    if (stem === "index" || isIgnoredPath(filename, ignore)) {
+      return {};
+    }
+    return {
+      Program(node) {
+        const primary = resolvePrimary(node.body);
+        if (primary === null || normalize(primary.name) === normalize(stem)) {
+          return;
+        }
+        const basename = getBasename(filename);
+        const canRename = VALID_IDENTIFIER.test(stem) && stem !== primary.name;
+        context.report({
+          node: primary.node,
+          messageId: "filenameMismatch",
+          data: { basename, name: primary.name, expected: stem },
+          suggest: canRename ? [
+            {
+              messageId: "renameExport",
+              data: { expected: stem },
+              fix: (fixer) => {
+                const variable = moduleVariable(context.sourceCode, primary.name);
+                if (variable !== null && !isImportBinding(variable)) {
+                  const targets = /* @__PURE__ */ new Map();
+                  for (const id of variable.identifiers) {
+                    targets.set(id.range[0], id);
+                  }
+                  for (const ref of variable.references) {
+                    targets.set(ref.identifier.range[0], ref.identifier);
+                  }
+                  return [...targets.values()].map((id) => fixer.replaceText(id, stem));
+                }
+                return [fixer.replaceText(primary.node, stem)];
+              }
+            }
+          ] : void 0
+        });
+      }
+    };
+  }
+});
+
 // src/rules/index-must-reexport-default.ts
-import path3 from "path";
-import { AST_NODE_TYPES } from "@typescript-eslint/utils";
-var RULE_NAME2 = "index-must-reexport-default";
+import path5 from "path";
+import { AST_NODE_TYPES as AST_NODE_TYPES3 } from "@typescript-eslint/utils";
+var RULE_NAME5 = "index-must-reexport-default";
 var DEFAULT_IGNORE_PATHS2 = [];
-var optionSchema2 = {
+var optionSchema5 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -187,17 +493,17 @@ function reexportsDefault(node) {
     return false;
   }
   return node.specifiers.some(
-    (specifier) => specifier.local.type === AST_NODE_TYPES.Identifier && specifier.local.name === "default"
+    (specifier) => specifier.local.type === AST_NODE_TYPES3.Identifier && specifier.local.name === "default"
   );
 }
 var indexMustReexportDefaultRule = createRule({
-  name: RULE_NAME2,
+  name: RULE_NAME5,
   meta: {
     type: "problem",
     docs: {
       description: "A component folder's `index.ts` must re-export the component default (`export { default as <Name> } from './<Name>'`)."
     },
-    schema: [optionSchema2],
+    schema: [optionSchema5],
     messages: {
       missingDefaultReexport: "`index.ts` must re-export the {{name}} default: `export { default as {{name}} } from './{{name}}'`."
     }
@@ -209,8 +515,8 @@ var indexMustReexportDefaultRule = createRule({
     if (getBasename(filename) !== "index.ts" || isIgnoredPath(filename, ignorePaths)) {
       return {};
     }
-    const dir = path3.dirname(filename);
-    const folderName = path3.basename(dir);
+    const dir = path5.dirname(filename);
+    const folderName = path5.basename(dir);
     if (!isPascalCase(folderName) || !siblingExists(dir, `${folderName}.tsx`)) {
       return {};
     }
@@ -234,14 +540,120 @@ var indexMustReexportDefaultRule = createRule({
   }
 });
 
+// src/rules/max-import-depth.ts
+import path6 from "path";
+import { AST_NODE_TYPES as AST_NODE_TYPES4 } from "@typescript-eslint/utils";
+var RULE_NAME6 = "max-import-depth";
+var DEFAULT_MAX = 3;
+var optionSchema6 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    max: { type: "integer", minimum: 0 },
+    alias: {
+      type: "object",
+      additionalProperties: { type: "string" }
+    }
+  }
+};
+function climbDepth(source) {
+  if (!source.startsWith(".")) {
+    return 0;
+  }
+  let depth = 0;
+  for (const segment of source.split("/")) {
+    if (segment === "..") {
+      depth += 1;
+    } else if (segment === ".") {
+      continue;
+    } else {
+      break;
+    }
+  }
+  return depth;
+}
+function aliasRewrite(source, currentFile, alias) {
+  const resolved = toPosix(path6.resolve(path6.dirname(currentFile), source));
+  for (const [anchor, prefix] of Object.entries(alias)) {
+    const marker = `/${anchor}/`;
+    const idx = resolved.lastIndexOf(marker);
+    if (idx === -1) {
+      continue;
+    }
+    const rest = resolved.slice(idx + marker.length);
+    if (rest.length === 0) {
+      continue;
+    }
+    return `${prefix}/${rest}`;
+  }
+  return null;
+}
+var maxImportDepthRule = createRule({
+  name: RULE_NAME6,
+  meta: {
+    type: "suggestion",
+    fixable: "code",
+    docs: {
+      description: "A relative import may not climb more than `max` parent levels (default 3). Autofixed to a path alias when one is configured."
+    },
+    schema: [optionSchema6],
+    messages: {
+      tooDeep: "Relative import `{{source}}` climbs {{depth}} levels \u2014 over the limit of {{max}}. Use a path alias instead of reaching this far up the tree."
+    }
+  },
+  defaultOptions: [{ max: DEFAULT_MAX, alias: {} }],
+  create(context, [options]) {
+    const max = options.max ?? DEFAULT_MAX;
+    const alias = options.alias ?? {};
+    const filename = context.filename;
+    function check(sourceNode) {
+      if (sourceNode === null || sourceNode === void 0 || typeof sourceNode.value !== "string") {
+        return;
+      }
+      const source = sourceNode.value;
+      const depth = climbDepth(source);
+      if (depth <= max) {
+        return;
+      }
+      const rewrite = aliasRewrite(source, filename, alias);
+      context.report({
+        node: sourceNode,
+        messageId: "tooDeep",
+        data: { source, depth, max },
+        fix: rewrite === null ? void 0 : (fixer) => {
+          const quote = sourceNode.raw.charAt(0);
+          return fixer.replaceText(sourceNode, `${quote}${rewrite}${quote}`);
+        }
+      });
+    }
+    function literalSource(node) {
+      return node !== null && node !== void 0 && node.type === AST_NODE_TYPES4.Literal ? node : null;
+    }
+    return {
+      ImportDeclaration(node) {
+        check(node.source);
+      },
+      ImportExpression(node) {
+        check(literalSource(node.source));
+      },
+      ExportNamedDeclaration(node) {
+        check(literalSource(node.source));
+      },
+      ExportAllDeclaration(node) {
+        check(literalSource(node.source));
+      }
+    };
+  }
+});
+
 // src/rules/no-cross-feature-imports.ts
-import path4 from "path";
-import { AST_NODE_TYPES as AST_NODE_TYPES2 } from "@typescript-eslint/utils";
-var RULE_NAME3 = "no-cross-feature-imports";
+import path7 from "path";
+import { AST_NODE_TYPES as AST_NODE_TYPES5 } from "@typescript-eslint/utils";
+var RULE_NAME7 = "no-cross-feature-imports";
 var DEFAULT_FEATURE_ROOT = "components";
 var DEFAULT_ALIAS = "@/components";
 var DEFAULT_SHARED_FEATURES = ["ui"];
-var optionSchema3 = {
+var optionSchema7 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -263,19 +675,19 @@ function resolveTargetFeature(source, currentFile, aliasRe, featureRoot) {
     return aliasMatch[1] ?? null;
   }
   if (source.startsWith(".")) {
-    const resolved = path4.resolve(path4.dirname(currentFile), source);
+    const resolved = path7.resolve(path7.dirname(currentFile), source);
     return getFeatureName(resolved, featureRoot);
   }
   return null;
 }
 var noCrossFeatureImportsRule = createRule({
-  name: RULE_NAME3,
+  name: RULE_NAME7,
   meta: {
     type: "problem",
     docs: {
       description: "A file in one feature may not import runtime code from another feature. Move shared code to a shared module or a shared feature."
     },
-    schema: [optionSchema3],
+    schema: [optionSchema7],
     messages: {
       crossFeatureImport: "Cross-feature import: `{{current}}` may not import runtime code from `{{root}}/{{target}}`. Move shared code to a shared module or a shared feature (e.g. `{{root}}/ui`)."
     }
@@ -318,25 +730,25 @@ var noCrossFeatureImportsRule = createRule({
     }
     return {
       ImportDeclaration(node) {
-        if (node.source.type === AST_NODE_TYPES2.Literal) {
+        if (node.source.type === AST_NODE_TYPES5.Literal) {
           checkSource(node.source, node.importKind === "type");
         }
       },
       // Dynamic `import()` is runtime by nature — never type-only.
       ImportExpression(node) {
-        if (node.source.type === AST_NODE_TYPES2.Literal) {
+        if (node.source.type === AST_NODE_TYPES5.Literal) {
           checkSource(node.source, false);
         }
       },
       // `export { x } from '…'` re-export laundering.
       ExportNamedDeclaration(node) {
-        if (node.source !== null && node.source.type === AST_NODE_TYPES2.Literal) {
+        if (node.source !== null && node.source.type === AST_NODE_TYPES5.Literal) {
           checkSource(node.source, node.exportKind === "type");
         }
       },
       // `export * from '…'` re-export laundering.
       ExportAllDeclaration(node) {
-        if (node.source.type === AST_NODE_TYPES2.Literal) {
+        if (node.source.type === AST_NODE_TYPES5.Literal) {
           checkSource(node.source, node.exportKind === "type");
         }
       }
@@ -346,14 +758,18 @@ var noCrossFeatureImportsRule = createRule({
 
 // src/rules/index.ts
 var rules = {
+  "barrel-purity": barrelPurityRule,
+  "colocated-test-required": colocatedTestRequiredRule,
   "component-folder-structure": componentFolderStructureRule,
+  "filename-matches-export": filenameMatchesExportRule,
   "index-must-reexport-default": indexMustReexportDefaultRule,
+  "max-import-depth": maxImportDepthRule,
   "no-cross-feature-imports": noCrossFeatureImportsRule
 };
 
 // src/index.ts
 var NAMESPACE = "noctcore-architecture";
-var VERSION = "0.1.0";
+var VERSION = "0.2.0";
 var plugin = {
   meta: { name: "@noctcore/eslint-plugin-architecture", version: VERSION },
   rules,

package/docs/rules/barrel-purity.md

@@ -0,0 +1,57 @@
+# `noctcore-architecture/barrel-purity`
+
+> A barrel (`index.ts` / `index.tsx`) must contain only re-exports — never local declarations, side effects, or default-exported values.
+
+## Why
+
+A barrel exists to present a folder's public surface. The moment it also *declares* something — a
+const, a function, a type, a default-exported value — or *does* something — a side-effect import, a
+top-level call — the barrel becomes a real module with behavior. Every consumer that imports the
+folder now silently pulls that behavior in, and the folder no longer has a clean, movable boundary.
+
+## What it flags
+
+Only `index.ts` / `index.tsx` (and the other index extensions) are inspected. Each top-level
+statement that is not a pure re-export is reported.
+
+```ts
+// index.ts
+
+export { Card } from './Card';          // ✓ named re-export
+export * from './Card.types';           // ✓ star re-export
+export * as card from './Card';         // ✓ namespace re-export
+export { default as Card } from './Card'; // ✓ default re-export
+import { a } from './a';                // ✓ import that feeds a re-export
+export { a };                           //   …its matching specifier
+export type { Props } from './Card';    // ✓ type re-export
+export default Card;                    // ✓ re-export of a binding by name
+
+export const helper = 1;                // ✗ local declaration
+export function build() {}              // ✗ local declaration
+export type T = string;                 // ✗ local declaration
+export default () => 1;                 // ✗ a value, not a re-export
+import './styles.css';                  // ✗ side-effect import
+console.log('hi');                      // ✗ side-effect statement
+const cache = new Map();                // ✗ non-export code
+```
+
+An import that carries bindings is allowed because it feeds a re-export; a specifier-less
+`import './x'` is a side effect and is flagged.
+
+## Options
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `allow` | `string[]` | `[]` | Globs (supporting `**`, `*`, `?`) of barrel paths to exempt entirely. |
+
+```js
+'noctcore-architecture/barrel-purity': ['error', {
+  allow: ['**/legacy/**'],
+}]
+```
+
+## When not to use it
+
+If you deliberately keep small helpers or feature flags inside a package's `index.ts`, this rule will
+fight you. Prefer moving them into a sibling module and re-exporting — but if you cannot, disable the
+rule for those paths via `allow`.