@noctcore/eslint-plugin-architecture 0.1.0

package/README.md

@@ -0,0 +1,51 @@
+# @noctcore/eslint-plugin-architecture
+
+Framework-agnostic folder-per-component and feature-boundary architecture rules. Flat-config only,
+ESLint 9+.
+
+## Install
+
+```sh
+bun add -D @noctcore/eslint-plugin-architecture   # or npm i -D / pnpm add -D
+```
+
+## Use
+
+```js
+// eslint.config.js
+import architecture from '@noctcore/eslint-plugin-architecture';
+
+export default [
+  architecture.configs.recommended,
+];
+```
+
+Or wire rules individually:
+
+```js
+import architecture from '@noctcore/eslint-plugin-architecture';
+
+export default [
+  {
+    plugins: { 'noctcore-architecture': architecture },
+    rules: {
+      'noctcore-architecture/component-folder-structure': ['error', { componentRoot: 'components' }],
+      'noctcore-architecture/no-cross-feature-imports': ['error', { alias: '@/components' }],
+      'noctcore-architecture/index-must-reexport-default': 'error',
+    },
+  },
+];
+```
+
+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.
+
+## Rules
+
+| Rule | Description | 🔧 |
+| --- | --- | --- |
+| [`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. | |
+| [`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. | |
+| [`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

@@ -0,0 +1,410 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  configs: () => configs,
+  default: () => index_default,
+  rules: () => rules
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/configs/recommended.ts
+var recommended = {
+  "noctcore-architecture/component-folder-structure": "error",
+  "noctcore-architecture/index-must-reexport-default": "error",
+  "noctcore-architecture/no-cross-feature-imports": "error"
+};
+
+// src/rules/component-folder-structure.ts
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/createRule.ts
+var import_eslint_utils = require("@noctcore/eslint-utils");
+var createRule = (0, import_eslint_utils.makeCreateRule)("architecture");
+
+// src/utils.ts
+var import_node_fs = require("fs");
+var import_node_path = __toESM(require("path"), 1);
+function toPosix(filename) {
+  return filename.split(import_node_path.default.sep).join("/").split("\\").join("/");
+}
+function getBasename(filename) {
+  return import_node_path.default.basename(filename);
+}
+function isPascalCase(segment) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(segment);
+}
+function isComponentFileName(filename) {
+  return /^[A-Z][A-Za-z0-9]*\.tsx$/.test(getBasename(filename));
+}
+function getComponentName(filename) {
+  return getBasename(filename).replace(/\.tsx$/, "");
+}
+function isComponentEntryFile(filename) {
+  if (!isComponentFileName(filename)) {
+    return false;
+  }
+  return getComponentName(filename) === import_node_path.default.basename(import_node_path.default.dirname(filename));
+}
+function segmentsAfterRoot(filename, root) {
+  const marker = `/${root}/`;
+  const posix = toPosix(filename);
+  const idx = posix.lastIndexOf(marker);
+  if (idx === -1) {
+    return null;
+  }
+  return posix.slice(idx + marker.length).split("/").filter((segment) => segment.length > 0);
+}
+function getFeatureName(filename, root) {
+  const segments = segmentsAfterRoot(filename, root);
+  if (segments === null || segments.length === 0) {
+    return null;
+  }
+  const feature = segments[0];
+  return feature !== void 0 && feature.length > 0 ? feature : null;
+}
+function escapeRegExpLiteral(value) {
+  return value.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+}
+function globToRegExp(glob) {
+  let out = "";
+  for (let i = 0; i < glob.length; i += 1) {
+    const char = glob[i];
+    if (char === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          out += "(?:[^/]*/)*";
+          i += 2;
+        } else {
+          out += ".*";
+          i += 1;
+        }
+      } else {
+        out += "[^/]*";
+      }
+    } else if (char === "?") {
+      out += "[^/]";
+    } else if (char !== void 0) {
+      out += escapeRegExpLiteral(char);
+    }
+  }
+  return new RegExp(`^${out}$`);
+}
+function isIgnoredPath(filename, ignorePaths) {
+  if (ignorePaths.length === 0) {
+    return false;
+  }
+  const posix = toPosix(filename);
+  return ignorePaths.some((glob) => globToRegExp(glob).test(posix));
+}
+function siblingExists(dir, sibling) {
+  return (0, import_node_fs.existsSync)(import_node_path.default.join(dir, sibling));
+}
+function readDirSafe(dir) {
+  try {
+    return new Set((0, import_node_fs.readdirSync)(dir));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+
+// src/rules/component-folder-structure.ts
+var RULE_NAME = "component-folder-structure";
+var DEFAULT_COMPONENT_ROOT = "components";
+var DEFAULT_IGNORE_PATHS = ["**/ui/**"];
+var DEFAULT_REQUIRED_SIBLINGS = [
+  ".hooks.ts",
+  ".types.ts",
+  ".stories.tsx",
+  ".test.tsx",
+  "index.ts"
+];
+function resolveSibling(template, name) {
+  return template.startsWith(".") ? `${name}${template}` : template;
+}
+var optionSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    componentRoot: { type: "string" },
+    requiredSiblings: { type: "array", items: { type: "string" }, uniqueItems: true },
+    ignorePaths: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+var componentFolderStructureRule = createRule({
+  name: RULE_NAME,
+  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],
+    messages: {
+      missingSiblings: "Component `{{name}}` is missing sibling file(s): {{missing}}. Every component folder must carry its hooks, types, stories, test, and index barrel."
+    }
+  },
+  defaultOptions: [
+    {
+      componentRoot: DEFAULT_COMPONENT_ROOT,
+      requiredSiblings: [...DEFAULT_REQUIRED_SIBLINGS],
+      ignorePaths: [...DEFAULT_IGNORE_PATHS]
+    }
+  ],
+  create(context, [options]) {
+    const componentRoot = options.componentRoot ?? DEFAULT_COMPONENT_ROOT;
+    const ignorePaths = options.ignorePaths ?? DEFAULT_IGNORE_PATHS;
+    const siblingTemplates = options.requiredSiblings ?? DEFAULT_REQUIRED_SIBLINGS;
+    const filename = context.filename;
+    if (!isComponentEntryFile(filename) || isIgnoredPath(filename, ignorePaths)) {
+      return {};
+    }
+    if (getFeatureName(filename, componentRoot) === null) {
+      return {};
+    }
+    const name = getComponentName(filename);
+    const dir = import_node_path2.default.dirname(filename);
+    const required = siblingTemplates.map((template) => resolveSibling(template, name));
+    const present = readDirSafe(dir);
+    const missing = required.filter((sibling) => !present.has(sibling));
+    return {
+      Program(node) {
+        if (missing.length > 0) {
+          context.report({
+            node,
+            messageId: "missingSiblings",
+            data: { name, missing: missing.join(", ") }
+          });
+        }
+      }
+    };
+  }
+});
+
+// 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 DEFAULT_IGNORE_PATHS2 = [];
+var optionSchema2 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    ignorePaths: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+function reexportsDefault(node) {
+  if (node.source === null) {
+    return false;
+  }
+  return node.specifiers.some(
+    (specifier) => specifier.local.type === import_utils2.AST_NODE_TYPES.Identifier && specifier.local.name === "default"
+  );
+}
+var indexMustReexportDefaultRule = createRule({
+  name: RULE_NAME2,
+  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],
+    messages: {
+      missingDefaultReexport: "`index.ts` must re-export the {{name}} default: `export { default as {{name}} } from './{{name}}'`."
+    }
+  },
+  defaultOptions: [{ ignorePaths: [] }],
+  create(context, [options]) {
+    const ignorePaths = options.ignorePaths ?? DEFAULT_IGNORE_PATHS2;
+    const filename = context.filename;
+    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);
+    if (!isPascalCase(folderName) || !siblingExists(dir, `${folderName}.tsx`)) {
+      return {};
+    }
+    let hasDefaultReexport = false;
+    return {
+      ExportNamedDeclaration(node) {
+        if (reexportsDefault(node)) {
+          hasDefaultReexport = true;
+        }
+      },
+      "Program:exit"(node) {
+        if (!hasDefaultReexport) {
+          context.report({
+            node,
+            messageId: "missingDefaultReexport",
+            data: { name: folderName }
+          });
+        }
+      }
+    };
+  }
+});
+
+// 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 DEFAULT_FEATURE_ROOT = "components";
+var DEFAULT_ALIAS = "@/components";
+var DEFAULT_SHARED_FEATURES = ["ui"];
+var optionSchema3 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    featureRoot: { type: "string" },
+    alias: { type: "string" },
+    sharedFeatures: { type: "array", items: { type: "string" }, uniqueItems: true },
+    allowTypeImports: { type: "boolean" }
+  }
+};
+function escapeRegExpLiteral2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function aliasFeatureMatcher(alias) {
+  return new RegExp(`^${escapeRegExpLiteral2(alias)}/([^/]+)`);
+}
+function resolveTargetFeature(source, currentFile, aliasRe, featureRoot) {
+  const aliasMatch = aliasRe.exec(source);
+  if (aliasMatch) {
+    return aliasMatch[1] ?? null;
+  }
+  if (source.startsWith(".")) {
+    const resolved = import_node_path4.default.resolve(import_node_path4.default.dirname(currentFile), source);
+    return getFeatureName(resolved, featureRoot);
+  }
+  return null;
+}
+var noCrossFeatureImportsRule = createRule({
+  name: RULE_NAME3,
+  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],
+    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`)."
+    }
+  },
+  defaultOptions: [
+    {
+      featureRoot: DEFAULT_FEATURE_ROOT,
+      alias: DEFAULT_ALIAS,
+      sharedFeatures: [...DEFAULT_SHARED_FEATURES],
+      allowTypeImports: true
+    }
+  ],
+  create(context, [options]) {
+    const featureRoot = options.featureRoot ?? DEFAULT_FEATURE_ROOT;
+    const alias = options.alias ?? DEFAULT_ALIAS;
+    const sharedFeatures = options.sharedFeatures ?? DEFAULT_SHARED_FEATURES;
+    const allowTypeImports = options.allowTypeImports ?? true;
+    const aliasRe = aliasFeatureMatcher(alias);
+    const current = getFeatureName(context.filename, featureRoot);
+    if (current === null) {
+      return {};
+    }
+    function checkSource(sourceNode, typeOnly) {
+      if (allowTypeImports && typeOnly) {
+        return;
+      }
+      const source = sourceNode.value;
+      if (typeof source !== "string") {
+        return;
+      }
+      const target = resolveTargetFeature(source, context.filename, aliasRe, featureRoot);
+      if (target === null || target === current || sharedFeatures.includes(target)) {
+        return;
+      }
+      context.report({
+        node: sourceNode,
+        messageId: "crossFeatureImport",
+        data: { current, target, root: featureRoot }
+      });
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.source.type === import_utils4.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) {
+          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) {
+          checkSource(node.source, node.exportKind === "type");
+        }
+      },
+      // `export * from '…'` re-export laundering.
+      ExportAllDeclaration(node) {
+        if (node.source.type === import_utils4.AST_NODE_TYPES.Literal) {
+          checkSource(node.source, node.exportKind === "type");
+        }
+      }
+    };
+  }
+});
+
+// src/rules/index.ts
+var rules = {
+  "component-folder-structure": componentFolderStructureRule,
+  "index-must-reexport-default": indexMustReexportDefaultRule,
+  "no-cross-feature-imports": noCrossFeatureImportsRule
+};
+
+// src/index.ts
+var NAMESPACE = "noctcore-architecture";
+var VERSION = "0.1.0";
+var plugin = {
+  meta: { name: "@noctcore/eslint-plugin-architecture", version: VERSION },
+  rules,
+  configs: {}
+};
+plugin.configs.recommended = {
+  plugins: { [NAMESPACE]: plugin },
+  rules: recommended
+};
+var configs = plugin.configs;
+var index_default = plugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  configs,
+  rules
+});

package/dist/index.d.cts

@@ -0,0 +1,54 @@
+import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+
+interface NoCrossFeatureImportsOptions {
+    readonly featureRoot?: string;
+    readonly alias?: string;
+    readonly sharedFeatures?: readonly string[];
+    readonly allowTypeImports?: boolean;
+}
+
+interface IndexMustReexportDefaultOptions {
+    readonly ignorePaths?: readonly string[];
+}
+
+interface ComponentFolderStructureOptions {
+    readonly componentRoot?: string;
+    readonly requiredSiblings?: readonly string[];
+    readonly ignorePaths?: readonly string[];
+}
+
+/** Every rule this plugin exposes, keyed by its (unprefixed) rule id. */
+declare const rules: {
+    'component-folder-structure': _typescript_eslint_utils_ts_eslint.RuleModule<"missingSiblings", [ComponentFolderStructureOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
+    'index-must-reexport-default': _typescript_eslint_utils_ts_eslint.RuleModule<"missingDefaultReexport", [IndexMustReexportDefaultOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
+    'no-cross-feature-imports': _typescript_eslint_utils_ts_eslint.RuleModule<"crossFeatureImport", [NoCrossFeatureImportsOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
+};
+
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'component-folder-structure': _typescript_eslint_utils_ts_eslint.RuleModule<"missingSiblings", [ComponentFolderStructureOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
+        'index-must-reexport-default': _typescript_eslint_utils_ts_eslint.RuleModule<"missingDefaultReexport", [IndexMustReexportDefaultOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
+        'no-cross-feature-imports': _typescript_eslint_utils_ts_eslint.RuleModule<"crossFeatureImport", [NoCrossFeatureImportsOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
+    };
+    configs: Record<string, unknown>;
+};
+
+declare const configs: Record<string, unknown>;
+
+export { configs, plugin as default, rules };

package/dist/index.d.ts

@@ -0,0 +1,54 @@
+import * as _typescript_eslint_utils_ts_eslint from '@typescript-eslint/utils/ts-eslint';
+
+interface NoCrossFeatureImportsOptions {
+    readonly featureRoot?: string;
+    readonly alias?: string;
+    readonly sharedFeatures?: readonly string[];
+    readonly allowTypeImports?: boolean;
+}
+
+interface IndexMustReexportDefaultOptions {
+    readonly ignorePaths?: readonly string[];
+}
+
+interface ComponentFolderStructureOptions {
+    readonly componentRoot?: string;
+    readonly requiredSiblings?: readonly string[];
+    readonly ignorePaths?: readonly string[];
+}
+
+/** Every rule this plugin exposes, keyed by its (unprefixed) rule id. */
+declare const rules: {
+    'component-folder-structure': _typescript_eslint_utils_ts_eslint.RuleModule<"missingSiblings", [ComponentFolderStructureOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
+    'index-must-reexport-default': _typescript_eslint_utils_ts_eslint.RuleModule<"missingDefaultReexport", [IndexMustReexportDefaultOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
+    'no-cross-feature-imports': _typescript_eslint_utils_ts_eslint.RuleModule<"crossFeatureImport", [NoCrossFeatureImportsOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+        name: string;
+    };
+};
+
+declare const plugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'component-folder-structure': _typescript_eslint_utils_ts_eslint.RuleModule<"missingSiblings", [ComponentFolderStructureOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
+        'index-must-reexport-default': _typescript_eslint_utils_ts_eslint.RuleModule<"missingDefaultReexport", [IndexMustReexportDefaultOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
+        'no-cross-feature-imports': _typescript_eslint_utils_ts_eslint.RuleModule<"crossFeatureImport", [NoCrossFeatureImportsOptions], unknown, _typescript_eslint_utils_ts_eslint.RuleListener> & {
+            name: string;
+        };
+    };
+    configs: Record<string, unknown>;
+};
+
+declare const configs: Record<string, unknown>;
+
+export { configs, plugin as default, rules };

package/dist/index.js

@@ -0,0 +1,372 @@
+// src/configs/recommended.ts
+var recommended = {
+  "noctcore-architecture/component-folder-structure": "error",
+  "noctcore-architecture/index-must-reexport-default": "error",
+  "noctcore-architecture/no-cross-feature-imports": "error"
+};
+
+// src/rules/component-folder-structure.ts
+import path2 from "path";
+
+// src/createRule.ts
+import { makeCreateRule } from "@noctcore/eslint-utils";
+var createRule = makeCreateRule("architecture");
+
+// src/utils.ts
+import { existsSync, readdirSync } from "fs";
+import path from "path";
+function toPosix(filename) {
+  return filename.split(path.sep).join("/").split("\\").join("/");
+}
+function getBasename(filename) {
+  return path.basename(filename);
+}
+function isPascalCase(segment) {
+  return /^[A-Z][A-Za-z0-9]*$/.test(segment);
+}
+function isComponentFileName(filename) {
+  return /^[A-Z][A-Za-z0-9]*\.tsx$/.test(getBasename(filename));
+}
+function getComponentName(filename) {
+  return getBasename(filename).replace(/\.tsx$/, "");
+}
+function isComponentEntryFile(filename) {
+  if (!isComponentFileName(filename)) {
+    return false;
+  }
+  return getComponentName(filename) === path.basename(path.dirname(filename));
+}
+function segmentsAfterRoot(filename, root) {
+  const marker = `/${root}/`;
+  const posix = toPosix(filename);
+  const idx = posix.lastIndexOf(marker);
+  if (idx === -1) {
+    return null;
+  }
+  return posix.slice(idx + marker.length).split("/").filter((segment) => segment.length > 0);
+}
+function getFeatureName(filename, root) {
+  const segments = segmentsAfterRoot(filename, root);
+  if (segments === null || segments.length === 0) {
+    return null;
+  }
+  const feature = segments[0];
+  return feature !== void 0 && feature.length > 0 ? feature : null;
+}
+function escapeRegExpLiteral(value) {
+  return value.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+}
+function globToRegExp(glob) {
+  let out = "";
+  for (let i = 0; i < glob.length; i += 1) {
+    const char = glob[i];
+    if (char === "*") {
+      if (glob[i + 1] === "*") {
+        if (glob[i + 2] === "/") {
+          out += "(?:[^/]*/)*";
+          i += 2;
+        } else {
+          out += ".*";
+          i += 1;
+        }
+      } else {
+        out += "[^/]*";
+      }
+    } else if (char === "?") {
+      out += "[^/]";
+    } else if (char !== void 0) {
+      out += escapeRegExpLiteral(char);
+    }
+  }
+  return new RegExp(`^${out}$`);
+}
+function isIgnoredPath(filename, ignorePaths) {
+  if (ignorePaths.length === 0) {
+    return false;
+  }
+  const posix = toPosix(filename);
+  return ignorePaths.some((glob) => globToRegExp(glob).test(posix));
+}
+function siblingExists(dir, sibling) {
+  return existsSync(path.join(dir, sibling));
+}
+function readDirSafe(dir) {
+  try {
+    return new Set(readdirSync(dir));
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+
+// src/rules/component-folder-structure.ts
+var RULE_NAME = "component-folder-structure";
+var DEFAULT_COMPONENT_ROOT = "components";
+var DEFAULT_IGNORE_PATHS = ["**/ui/**"];
+var DEFAULT_REQUIRED_SIBLINGS = [
+  ".hooks.ts",
+  ".types.ts",
+  ".stories.tsx",
+  ".test.tsx",
+  "index.ts"
+];
+function resolveSibling(template, name) {
+  return template.startsWith(".") ? `${name}${template}` : template;
+}
+var optionSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    componentRoot: { type: "string" },
+    requiredSiblings: { type: "array", items: { type: "string" }, uniqueItems: true },
+    ignorePaths: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+var componentFolderStructureRule = createRule({
+  name: RULE_NAME,
+  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],
+    messages: {
+      missingSiblings: "Component `{{name}}` is missing sibling file(s): {{missing}}. Every component folder must carry its hooks, types, stories, test, and index barrel."
+    }
+  },
+  defaultOptions: [
+    {
+      componentRoot: DEFAULT_COMPONENT_ROOT,
+      requiredSiblings: [...DEFAULT_REQUIRED_SIBLINGS],
+      ignorePaths: [...DEFAULT_IGNORE_PATHS]
+    }
+  ],
+  create(context, [options]) {
+    const componentRoot = options.componentRoot ?? DEFAULT_COMPONENT_ROOT;
+    const ignorePaths = options.ignorePaths ?? DEFAULT_IGNORE_PATHS;
+    const siblingTemplates = options.requiredSiblings ?? DEFAULT_REQUIRED_SIBLINGS;
+    const filename = context.filename;
+    if (!isComponentEntryFile(filename) || isIgnoredPath(filename, ignorePaths)) {
+      return {};
+    }
+    if (getFeatureName(filename, componentRoot) === null) {
+      return {};
+    }
+    const name = getComponentName(filename);
+    const dir = path2.dirname(filename);
+    const required = siblingTemplates.map((template) => resolveSibling(template, name));
+    const present = readDirSafe(dir);
+    const missing = required.filter((sibling) => !present.has(sibling));
+    return {
+      Program(node) {
+        if (missing.length > 0) {
+          context.report({
+            node,
+            messageId: "missingSiblings",
+            data: { name, missing: missing.join(", ") }
+          });
+        }
+      }
+    };
+  }
+});
+
+// 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";
+var DEFAULT_IGNORE_PATHS2 = [];
+var optionSchema2 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    ignorePaths: { type: "array", items: { type: "string" }, uniqueItems: true }
+  }
+};
+function reexportsDefault(node) {
+  if (node.source === null) {
+    return false;
+  }
+  return node.specifiers.some(
+    (specifier) => specifier.local.type === AST_NODE_TYPES.Identifier && specifier.local.name === "default"
+  );
+}
+var indexMustReexportDefaultRule = createRule({
+  name: RULE_NAME2,
+  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],
+    messages: {
+      missingDefaultReexport: "`index.ts` must re-export the {{name}} default: `export { default as {{name}} } from './{{name}}'`."
+    }
+  },
+  defaultOptions: [{ ignorePaths: [] }],
+  create(context, [options]) {
+    const ignorePaths = options.ignorePaths ?? DEFAULT_IGNORE_PATHS2;
+    const filename = context.filename;
+    if (getBasename(filename) !== "index.ts" || isIgnoredPath(filename, ignorePaths)) {
+      return {};
+    }
+    const dir = path3.dirname(filename);
+    const folderName = path3.basename(dir);
+    if (!isPascalCase(folderName) || !siblingExists(dir, `${folderName}.tsx`)) {
+      return {};
+    }
+    let hasDefaultReexport = false;
+    return {
+      ExportNamedDeclaration(node) {
+        if (reexportsDefault(node)) {
+          hasDefaultReexport = true;
+        }
+      },
+      "Program:exit"(node) {
+        if (!hasDefaultReexport) {
+          context.report({
+            node,
+            messageId: "missingDefaultReexport",
+            data: { name: folderName }
+          });
+        }
+      }
+    };
+  }
+});
+
+// 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";
+var DEFAULT_FEATURE_ROOT = "components";
+var DEFAULT_ALIAS = "@/components";
+var DEFAULT_SHARED_FEATURES = ["ui"];
+var optionSchema3 = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    featureRoot: { type: "string" },
+    alias: { type: "string" },
+    sharedFeatures: { type: "array", items: { type: "string" }, uniqueItems: true },
+    allowTypeImports: { type: "boolean" }
+  }
+};
+function escapeRegExpLiteral2(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function aliasFeatureMatcher(alias) {
+  return new RegExp(`^${escapeRegExpLiteral2(alias)}/([^/]+)`);
+}
+function resolveTargetFeature(source, currentFile, aliasRe, featureRoot) {
+  const aliasMatch = aliasRe.exec(source);
+  if (aliasMatch) {
+    return aliasMatch[1] ?? null;
+  }
+  if (source.startsWith(".")) {
+    const resolved = path4.resolve(path4.dirname(currentFile), source);
+    return getFeatureName(resolved, featureRoot);
+  }
+  return null;
+}
+var noCrossFeatureImportsRule = createRule({
+  name: RULE_NAME3,
+  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],
+    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`)."
+    }
+  },
+  defaultOptions: [
+    {
+      featureRoot: DEFAULT_FEATURE_ROOT,
+      alias: DEFAULT_ALIAS,
+      sharedFeatures: [...DEFAULT_SHARED_FEATURES],
+      allowTypeImports: true
+    }
+  ],
+  create(context, [options]) {
+    const featureRoot = options.featureRoot ?? DEFAULT_FEATURE_ROOT;
+    const alias = options.alias ?? DEFAULT_ALIAS;
+    const sharedFeatures = options.sharedFeatures ?? DEFAULT_SHARED_FEATURES;
+    const allowTypeImports = options.allowTypeImports ?? true;
+    const aliasRe = aliasFeatureMatcher(alias);
+    const current = getFeatureName(context.filename, featureRoot);
+    if (current === null) {
+      return {};
+    }
+    function checkSource(sourceNode, typeOnly) {
+      if (allowTypeImports && typeOnly) {
+        return;
+      }
+      const source = sourceNode.value;
+      if (typeof source !== "string") {
+        return;
+      }
+      const target = resolveTargetFeature(source, context.filename, aliasRe, featureRoot);
+      if (target === null || target === current || sharedFeatures.includes(target)) {
+        return;
+      }
+      context.report({
+        node: sourceNode,
+        messageId: "crossFeatureImport",
+        data: { current, target, root: featureRoot }
+      });
+    }
+    return {
+      ImportDeclaration(node) {
+        if (node.source.type === AST_NODE_TYPES2.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) {
+          checkSource(node.source, false);
+        }
+      },
+      // `export { x } from '…'` re-export laundering.
+      ExportNamedDeclaration(node) {
+        if (node.source !== null && node.source.type === AST_NODE_TYPES2.Literal) {
+          checkSource(node.source, node.exportKind === "type");
+        }
+      },
+      // `export * from '…'` re-export laundering.
+      ExportAllDeclaration(node) {
+        if (node.source.type === AST_NODE_TYPES2.Literal) {
+          checkSource(node.source, node.exportKind === "type");
+        }
+      }
+    };
+  }
+});
+
+// src/rules/index.ts
+var rules = {
+  "component-folder-structure": componentFolderStructureRule,
+  "index-must-reexport-default": indexMustReexportDefaultRule,
+  "no-cross-feature-imports": noCrossFeatureImportsRule
+};
+
+// src/index.ts
+var NAMESPACE = "noctcore-architecture";
+var VERSION = "0.1.0";
+var plugin = {
+  meta: { name: "@noctcore/eslint-plugin-architecture", version: VERSION },
+  rules,
+  configs: {}
+};
+plugin.configs.recommended = {
+  plugins: { [NAMESPACE]: plugin },
+  rules: recommended
+};
+var configs = plugin.configs;
+var index_default = plugin;
+export {
+  configs,
+  index_default as default,
+  rules
+};

package/docs/rules/component-folder-structure.md

@@ -0,0 +1,50 @@
+# `noctcore-architecture/component-folder-structure`
+
+> A component entry file must ship its full sibling set (hooks, types, story, test, barrel) on disk.
+
+## Why
+
+In a folder-per-component layout, a component is a folder — not a lone `.tsx`. When the logic
+(`.hooks.ts`), the types (`.types.ts`), the story (`.stories.tsx`), the test (`.test.tsx`), and the
+`index.ts` barrel always travel with the component, refactors stay local and nothing is quietly
+untested or undocumented. This rule enforces that colocation by construction.
+
+## What it flags
+
+For every **component entry file** — a PascalCase `.tsx` whose basename equals its parent folder
+(`TaskCard/TaskCard.tsx`) — that lives under the configured `componentRoot`, the rule reads the
+component's directory and reports any sibling from the required set that is missing on disk.
+
+```
+components/board/TaskCard/
+  TaskCard.tsx          ← entry file (checked)
+  TaskCard.hooks.ts     ┐
+  TaskCard.types.ts     │ required siblings
+  TaskCard.stories.tsx  │ (missing → reported)
+  TaskCard.test.tsx     │
+  index.ts              ┘
+```
+
+Files that are not entry files (`task-card.tsx`, `Group/Widget.tsx`), files outside the
+`componentRoot`, and files matched by `ignorePaths` are never checked.
+
+## Options
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `componentRoot` | `string` | `'components'` | The directory segment the layout is anchored on. |
+| `requiredSiblings` | `string[]` | `['.hooks.ts', '.types.ts', '.stories.tsx', '.test.tsx', 'index.ts']` | The sibling set. An entry starting with `.` is a name-relative suffix (`.hooks.ts` → `<Name>.hooks.ts`); any other entry is a literal filename (`index.ts`). |
+| `ignorePaths` | `string[]` | `['**/ui/**']` | Globs (supporting `**`, `*`, `?`) of paths to skip. |
+
+```js
+'noctcore-architecture/component-folder-structure': ['error', {
+  componentRoot: 'components',
+  requiredSiblings: ['.hooks.ts', '.types.ts', '.stories.tsx', '.test.tsx', 'index.ts'],
+  ignorePaths: ['**/ui/**'],
+}]
+```
+
+## When not to use it
+
+If your components are single files rather than folders, or you do not colocate stories/tests with
+components, disable this rule or trim `requiredSiblings` to just the pieces you do colocate.

package/docs/rules/index-must-reexport-default.md

@@ -0,0 +1,44 @@
+# `noctcore-architecture/index-must-reexport-default`
+
+> A component folder's `index.ts` must re-export the sibling default named after the folder.
+
+## Why
+
+When a component folder's `index.ts` re-exports the component default, consumers import the folder
+(`import Card from '@/components/Card'`) rather than reaching for the inner file
+(`.../Card/Card`). The barrel becomes the folder's single public entry point, and the internal file
+layout stays free to change.
+
+## What it flags
+
+The rule only activates for an `index.ts` that sits next to a `<Folder>.tsx` of the same PascalCase
+name on disk (`Card/Card.tsx` beside `Card/index.ts`). For those barrels, it reports when the file
+never re-exports the sibling's default export.
+
+```ts
+// Card/index.ts
+
+export { default as Card } from './Card'; // ✓
+export { default } from './Card';         // ✓
+export * from './Card.types';             // ✗ (on its own — no default re-export)
+```
+
+Non-component `index.ts` files — those whose folder is not PascalCase, or that have no
+`<Folder>.tsx` sibling on disk — are left untouched.
+
+## Options
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `ignorePaths` | `string[]` | `[]` | Globs (supporting `**`, `*`, `?`) of paths to skip. |
+
+```js
+'noctcore-architecture/index-must-reexport-default': ['error', {
+  ignorePaths: ['**/ui/**'],
+}]
+```
+
+## When not to use it
+
+If you do not use barrel files, or you export components as named (not default) exports, this rule
+does not apply.

package/docs/rules/no-cross-feature-imports.md

@@ -0,0 +1,57 @@
+# `noctcore-architecture/no-cross-feature-imports`
+
+> A file in one feature may not import runtime code from another feature.
+
+## Why
+
+Features are meant to be decoupled: a change inside feature `board` should never be able to ripple
+into feature `projects`. When one feature reaches directly into another's internals, that boundary
+erodes and the two become one tangled unit. Shared code belongs outside the feature root (a `lib`,
+`hooks`, or similar module) or in a designated **shared feature** (default `ui`) that everything is
+allowed to import.
+
+## What it flags
+
+For a file that lives under `<featureRoot>/<feature>/…`, the rule reports any import whose target
+resolves to a **different** feature under the same root, on every source-carrying construct:
+
+- static `import … from '…'`
+- dynamic `import('…')`
+- `export … from '…'` and `export * from '…'` re-export laundering
+
+Both the alias form (`<alias>/<feature>/…`) and relative paths that climb into another feature
+(`../../projects/…`) are detected. Type-only imports are allowed by default (flip `allowTypeImports`
+to forbid them). Imports of the current feature, of a shared feature, or of non-feature modules are
+always fine.
+
+```tsx
+// in components/board/Board/Board.tsx
+
+import { Button } from '@/components/ui/Button';         // ✓ shared feature
+import { cn } from '@/lib/utils';                        // ✓ non-feature module
+import { TaskCard } from '../TaskCard/TaskCard';         // ✓ same feature
+import { ProjectCard } from '@/components/projects/…';   // ✗ cross-feature
+```
+
+## Options
+
+| Option | Type | Default | Meaning |
+| --- | --- | --- | --- |
+| `featureRoot` | `string` | `'components'` | The directory segment whose immediate children are features. |
+| `alias` | `string` | `'@/components'` | The import-alias prefix that maps onto `featureRoot`. |
+| `sharedFeatures` | `string[]` | `['ui']` | Features every other feature is allowed to import. |
+| `allowTypeImports` | `boolean` | `true` | When `true`, `import type` / `export type` cross-feature imports are permitted. |
+
+```js
+'noctcore-architecture/no-cross-feature-imports': ['error', {
+  featureRoot: 'components',
+  alias: '@/components',
+  sharedFeatures: ['ui'],
+  allowTypeImports: true,
+}]
+```
+
+## When not to use it
+
+If your app is not organized as sibling features under a single root, or you allow features to
+depend on each other freely, this rule does not apply.

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@noctcore/eslint-plugin-architecture",
+  "version": "0.1.0",
+  "description": "Framework-agnostic folder-per-component and feature-boundary architecture ESLint rules.",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "docs",
+    "README.md"
+  ],
+  "sideEffects": false,
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "eslint-plugin",
+    "architecture",
+    "noctcore"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/noctcore/eslint-plugins.git",
+    "directory": "packages/eslint-plugin-architecture"
+  },
+  "homepage": "https://github.com/noctcore/eslint-plugins/tree/main/packages/eslint-plugin-architecture",
+  "bugs": "https://github.com/noctcore/eslint-plugins/issues",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@noctcore/eslint-utils": "^0.1.0",
+    "@typescript-eslint/utils": "^8.61.1"
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0",
+    "typescript": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@noctcore/eslint-test-utils": "workspace:*",
+    "@types/node": "^22.0.0",
+    "@typescript-eslint/parser": "^8.61.1",
+    "@typescript-eslint/rule-tester": "^8.61.1",
+    "tsup": "^8.5.1",
+    "typescript": "^5.6.0",
+    "vitest": "^3"
+  }
+}