@noctcore/eslint-plugin-architecture 0.1.0 → 0.2.0

package/README.md

@@ -39,13 +39,19 @@ export default [
 
 Every rule anchors on a configurable directory segment (default `components`) rather than an absolute
 path, so it behaves the same whether ESLint runs from the repo root or per-package, on POSIX or
-Windows. Two of the three rules inspect files on disk (sibling sets, barrel siblings), so run ESLint
-against real file paths, not virtual sources.
+Windows. Several rules inspect files on disk (sibling sets, barrel siblings, colocated tests), so run
+ESLint against real file paths, not virtual sources.
 
 ## Rules
 
+🔧 = autofixable · 💡 = provides an editor suggestion.
+
 | Rule | Description | 🔧 |
 | --- | --- | --- |
+| [`barrel-purity`](./docs/rules/barrel-purity.md) | A barrel (`index.ts` / `index.tsx`) must contain only re-exports — no local declarations, side effects, or default-exported values. | |
+| [`colocated-test-required`](./docs/rules/colocated-test-required.md) | A source file matching an `include` glob must have a colocated `*.test.*` / `*.spec.*` sibling on disk. Off until configured. | |
 | [`component-folder-structure`](./docs/rules/component-folder-structure.md) | A component entry file must ship its full sibling set (hooks, types, story, test, barrel) on disk. | |
+| [`filename-matches-export`](./docs/rules/filename-matches-export.md) | A file's basename must match its primary export (default export, or the sole named export). | 💡 |
 | [`index-must-reexport-default`](./docs/rules/index-must-reexport-default.md) | A component folder's `index.ts` must re-export the sibling default named after the folder. | |
+| [`max-import-depth`](./docs/rules/max-import-depth.md) | A relative import may not climb more than `max` parent levels (default 3); autofixed to a path alias when one is configured. | 🔧 |
 | [`no-cross-feature-imports`](./docs/rules/no-cross-feature-imports.md) | A file in one feature may not import runtime code from another feature. | |

package/dist/index.cjs

@@ -38,13 +38,21 @@ module.exports = __toCommonJS(index_exports);
 
 // 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
-var import_node_path2 = __toESM(require("path"), 1);
+// src/rules/barrel-purity.ts
+var import_utils = require("@typescript-eslint/utils");
 
 // src/createRule.ts
 var import_eslint_utils = require("@noctcore/eslint-utils");
@@ -136,8 +144,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 import_utils.AST_NODE_TYPES.ImportDeclaration:
+      return stmt.specifiers.length === 0 ? "a side-effect import" : null;
+    case import_utils.AST_NODE_TYPES.ExportAllDeclaration:
+      return null;
+    case import_utils.AST_NODE_TYPES.ExportNamedDeclaration:
+      if (stmt.source !== null) {
+        return null;
+      }
+      if (stmt.declaration === null) {
+        return null;
+      }
+      return "a local declaration";
+    case import_utils.AST_NODE_TYPES.ExportDefaultDeclaration:
+      return stmt.declaration.type === import_utils.AST_NODE_TYPES.Identifier ? null : "a default-exported value";
+    case import_utils.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
+var import_node_fs2 = require("fs");
+var import_node_path2 = __toESM(require("path"), 1);
+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 = (0, import_node_fs2.readdirSync)(dir);
+  } catch {
+    entries = [];
+  }
+  dirCache.set(dir, entries);
+  return entries;
+}
+function stemOf(basename) {
+  const ext = import_node_path2.default.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 = import_node_path2.default.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";
+var import_node_path3 = __toESM(require("path"), 1);
+var RULE_NAME3 = "component-folder-structure";
 var DEFAULT_COMPONENT_ROOT = "components";
 var DEFAULT_IGNORE_PATHS = ["**/ui/**"];
 var DEFAULT_REQUIRED_SIBLINGS = [
@@ -150,7 +304,7 @@ var DEFAULT_REQUIRED_SIBLINGS = [
 function resolveSibling(template, name) {
   return template.startsWith(".") ? `${name}${template}` : template;
 }
-var optionSchema = {
+var optionSchema3 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -160,13 +314,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."
     }
@@ -190,7 +344,7 @@ var componentFolderStructureRule = createRule({
       return {};
     }
     const name = getComponentName(filename);
-    const dir = import_node_path2.default.dirname(filename);
+    const dir = import_node_path3.default.dirname(filename);
     const required = siblingTemplates.map((template) => resolveSibling(template, name));
     const present = readDirSafe(dir);
     const missing = required.filter((sibling) => !present.has(sibling));
@@ -208,12 +362,164 @@ var componentFolderStructureRule = createRule({
   }
 });
 
+// src/rules/filename-matches-export.ts
+var import_node_path4 = __toESM(require("path"), 1);
+var import_utils5 = require("@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 = import_node_path4.default.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 import_utils5.AST_NODE_TYPES.FunctionDeclaration:
+    case import_utils5.AST_NODE_TYPES.ClassDeclaration:
+      return d.id;
+    case import_utils5.AST_NODE_TYPES.TSTypeAliasDeclaration:
+    case import_utils5.AST_NODE_TYPES.TSInterfaceDeclaration:
+    case import_utils5.AST_NODE_TYPES.TSEnumDeclaration:
+      return d.id;
+    case import_utils5.AST_NODE_TYPES.VariableDeclaration: {
+      const only = d.declarations.length === 1 ? d.declarations[0] : void 0;
+      return only !== void 0 && only.id.type === import_utils5.AST_NODE_TYPES.Identifier ? only.id : null;
+    }
+    default:
+      return null;
+  }
+}
+function defaultExportId(decl) {
+  const d = decl.declaration;
+  if ((d.type === import_utils5.AST_NODE_TYPES.FunctionDeclaration || d.type === import_utils5.AST_NODE_TYPES.ClassDeclaration) && d.id !== null) {
+    return d.id;
+  }
+  return d.type === import_utils5.AST_NODE_TYPES.Identifier ? d : null;
+}
+function resolvePrimary(body) {
+  let hasDefault = false;
+  let defaultId = null;
+  const named = [];
+  for (const stmt of body) {
+    if (stmt.type === import_utils5.AST_NODE_TYPES.ExportDefaultDeclaration) {
+      hasDefault = true;
+      defaultId = defaultExportId(stmt);
+    } else if (stmt.type === import_utils5.AST_NODE_TYPES.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 === import_utils5.AST_NODE_TYPES.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([
+  import_utils5.AST_NODE_TYPES.ImportSpecifier,
+  import_utils5.AST_NODE_TYPES.ImportDefaultSpecifier,
+  import_utils5.AST_NODE_TYPES.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
-var import_node_path3 = __toESM(require("path"), 1);
-var import_utils2 = require("@typescript-eslint/utils");
-var RULE_NAME2 = "index-must-reexport-default";
+var import_node_path5 = __toESM(require("path"), 1);
+var import_utils7 = require("@typescript-eslint/utils");
+var RULE_NAME5 = "index-must-reexport-default";
 var DEFAULT_IGNORE_PATHS2 = [];
-var optionSchema2 = {
+var optionSchema5 = {
   type: "object",
   additionalProperties: false,
   properties: {
@@ -225,17 +531,17 @@ function reexportsDefault(node) {
     return false;
   }
   return node.specifiers.some(
-    (specifier) => specifier.local.type === import_utils2.AST_NODE_TYPES.Identifier && specifier.local.name === "default"
+    (specifier) => specifier.local.type === import_utils7.AST_NODE_TYPES.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}}'`."
     }
@@ -247,8 +553,8 @@ var indexMustReexportDefaultRule = createRule({
     if (getBasename(filename) !== "index.ts" || isIgnoredPath(filename, ignorePaths)) {
       return {};
     }
-    const dir = import_node_path3.default.dirname(filename);
-    const folderName = import_node_path3.default.basename(dir);
+    const dir = import_node_path5.default.dirname(filename);
+    const folderName = import_node_path5.default.basename(dir);
     if (!isPascalCase(folderName) || !siblingExists(dir, `${folderName}.tsx`)) {
       return {};
     }
@@ -272,14 +578,120 @@ var indexMustReexportDefaultRule = createRule({
   }
 });
 
+// src/rules/max-import-depth.ts
+var import_node_path6 = __toESM(require("path"), 1);
+var import_utils9 = require("@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(import_node_path6.default.resolve(import_node_path6.default.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 === import_utils9.AST_NODE_TYPES.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
-var import_node_path4 = __toESM(require("path"), 1);
-var import_utils4 = require("@typescript-eslint/utils");
-var RULE_NAME3 = "no-cross-feature-imports";
+var import_node_path7 = __toESM(require("path"), 1);
+var import_utils11 = require("@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: {
@@ -301,19 +713,19 @@ function resolveTargetFeature(source, currentFile, aliasRe, featureRoot) {
     return aliasMatch[1] ?? null;
   }
   if (source.startsWith(".")) {
-    const resolved = import_node_path4.default.resolve(import_node_path4.default.dirname(currentFile), source);
+    const resolved = import_node_path7.default.resolve(import_node_path7.default.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`)."
     }
@@ -356,25 +768,25 @@ var noCrossFeatureImportsRule = createRule({
     }
     return {
       ImportDeclaration(node) {
-        if (node.source.type === import_utils4.AST_NODE_TYPES.Literal) {
+        if (node.source.type === import_utils11.AST_NODE_TYPES.Literal) {
           checkSource(node.source, node.importKind === "type");
         }
       },
       // Dynamic `import()` is runtime by nature — never type-only.
       ImportExpression(node) {
-        if (node.source.type === import_utils4.AST_NODE_TYPES.Literal) {
+        if (node.source.type === import_utils11.AST_NODE_TYPES.Literal) {
           checkSource(node.source, false);
         }
       },
       // `export { x } from '…'` re-export laundering.
       ExportNamedDeclaration(node) {
-        if (node.source !== null && node.source.type === import_utils4.AST_NODE_TYPES.Literal) {
+        if (node.source !== null && node.source.type === import_utils11.AST_NODE_TYPES.Literal) {
           checkSource(node.source, node.exportKind === "type");
         }
       },
       // `export * from '…'` re-export laundering.
       ExportAllDeclaration(node) {
-        if (node.source.type === import_utils4.AST_NODE_TYPES.Literal) {
+        if (node.source.type === import_utils11.AST_NODE_TYPES.Literal) {
           checkSource(node.source, node.exportKind === "type");
         }
       }
@@ -384,14 +796,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,