@yasainet/eslint-next 0.1.0

package/README.md

@@ -0,0 +1,106 @@
+# @yasainet/eslint-next
+
+Shared ESLint configuration for Next.js projects with feature-based architecture.
+
+## Install
+
+```sh
+npm install -D @yasainet/eslint-next eslint eslint-config-next
+```
+
+## Usage
+
+```js
+// eslint.config.mjs
+import { eslintConfig } from "@yasainet/eslint-next";
+
+export default eslintConfig;
+```
+
+## Rules
+
+### Base
+
+Next.js recommended presets (core-web-vitals + typescript) with additional rules:
+
+- `@typescript-eslint/consistent-type-imports` — enforce `type` imports
+- `@typescript-eslint/no-unused-vars` — disallow unused variables (allows `_` prefix)
+- `no-console` — warn on `console.*`
+- `simple-import-sort` — auto-sort imports/exports
+- `@stylistic/quotes` — enforce double quotes
+- `react-you-might-not-need-an-effect` — detect unnecessary `useEffect`
+
+### Naming
+
+Enforces file naming conventions inside `features/`:
+
+| Directory       | Pattern              | Example            |
+| --------------- | -------------------- | ------------------ |
+| `domain/`       | `{prefix}.domain.ts` | `server.domain.ts` |
+| `repositories/` | `{prefix}.repo.ts`   | `server.repo.ts`   |
+| `actions/`      | `{prefix}.action.ts` | `server.action.ts` |
+| `hooks/`        | `use{Name}.ts`       | `useAuth.ts`       |
+| `types/`        | `{name}.type.ts`     | `comic.type.ts`    |
+| `schemas/`      | `{name}.schema.ts`   | `comic.schema.ts`  |
+| `util/`         | `{name}.util.ts`     | `format.util.ts`   |
+| `constants/`    | `{name}.constant.ts` | `api.constant.ts`  |
+
+Additionally:
+
+- `features/**` — `.ts` only (components belong in `src/components/`)
+- `components/**` — `.tsx` only (logic belongs in `src/features/`)
+
+### Layers
+
+Enforces dependency direction between layers:
+
+```
+hooks → actions → domain → repositories
+```
+
+- **Repositories** — cannot import domain/actions/hooks, no `try-catch` or `if`
+- **Domain** — cannot import actions/hooks, no `try-catch`
+- **Actions** — cannot import hooks, exports must start with `handle`
+- **Hooks** — exports must start with `use`
+
+Cross-feature imports within the same layer are prohibited.
+
+### Cardinality
+
+Each action can only import its matching domain:
+
+- `server.action.ts` → `server.domain.ts`
+- `client.action.ts` → `client.domain.ts`
+- `admin.action.ts` → `admin.domain.ts`
+
+### Directives
+
+Enforces `"use server"` / `"use client"` directives:
+
+- `server.action.ts` / `admin.action.ts` — must start with `"use server"`
+- `client.action.ts` — must NOT have `"use server"`
+- `hooks/*.ts` — must start with `"use client"`
+
+### Imports
+
+Each `{prefix}.repo.ts` can only import its corresponding lib (auto-generated from `src/lib/`):
+
+- `server.repo.ts` → `@/lib/supabase/server`
+- `client.repo.ts` → `@/lib/supabase/client`
+
+## Release
+
+1. Update `version` in `package.json`
+2. Commit and push to `main`
+3. Create and push a tag:
+
+```sh
+git tag v0.1.0
+git push --tags
+```
+
+4. GitHub Actions will automatically publish to npm
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@yasainet/eslint-next",
+  "version": "0.1.0",
+  "description": "Shared ESLint configuration for Next.js projects with feature-based architecture",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "files": [
+    "src"
+  ],
+  "keywords": [
+    "eslint",
+    "eslintconfig",
+    "nextjs",
+    "typescript"
+  ],
+  "author": "yasainet",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@stylistic/eslint-plugin": "^5.9.0",
+    "eslint-plugin-check-file": "^3.3.1",
+    "eslint-plugin-jsdoc": "^62.7.1",
+    "eslint-plugin-react-you-might-not-need-an-effect": "^0.5.6",
+    "eslint-plugin-simple-import-sort": "^12.1.1"
+  },
+  "peerDependencies": {
+    "eslint": "^9",
+    "eslint-config-next": "^15 || ^16"
+  }
+}

package/src/base.mjs

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview Base ESLint configurations including Next.js presets and shared rules.
+ */
+
+import { globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+import {
+  reactYouMightNotNeedAnEffect,
+  simpleImportSortPlugin,
+  stylistic,
+} from "./plugins.mjs";
+
+/**
+ * Next.js base configurations (core-web-vitals + typescript).
+ * @type {import("eslint").Linter.Config[]}
+ */
+export const baseConfigs = [...nextVitals, ...nextTs];
+
+/**
+ * Global ignore patterns for build outputs and generated files.
+ * @type {import("eslint").Linter.Config}
+ */
+export const ignoresConfig = globalIgnores([
+  ".backup/**", // NOTE: Not a default.
+  ".next/**",
+  "out/**",
+  "build/**",
+  "next-env.d.ts",
+]);
+
+/**
+ * Shared rules applied to all files.
+ * Includes stylistic rules, import sorting, and TypeScript best practices.
+ * @type {import("eslint").Linter.Config}
+ */
+export const sharedRulesConfig = {
+  name: "shared-rules",
+  plugins: {
+    "@stylistic": stylistic,
+    "react-you-might-not-need-an-effect": reactYouMightNotNeedAnEffect,
+    "simple-import-sort": simpleImportSortPlugin,
+  },
+  rules: {
+    ...reactYouMightNotNeedAnEffect.configs.recommended.rules,
+    "@typescript-eslint/no-unused-vars": [
+      "error",
+      {
+        argsIgnorePattern: "^_",
+        varsIgnorePattern: "^_",
+        caughtErrorsIgnorePattern: "^_",
+      },
+    ],
+    "@typescript-eslint/consistent-type-imports": [
+      "error",
+      { prefer: "type-imports" },
+    ],
+    "@typescript-eslint/no-explicit-any": "warn",
+    "no-console": "warn",
+    "no-irregular-whitespace": [
+      "warn",
+      {
+        skipStrings: false,
+        skipComments: false,
+        skipRegExps: false,
+        skipTemplates: false,
+      },
+    ],
+    "simple-import-sort/imports": "warn",
+    "simple-import-sort/exports": "warn",
+    "@stylistic/quotes": ["warn", "double", { avoidEscape: true }],
+  },
+};

package/src/cardinality.mjs

@@ -0,0 +1,71 @@
+/**
+ * @fileoverview Cardinality constraints for action-domain relationships.
+ *
+ * Each action file can only import its matching domain:
+ * - server.action.ts → server.domain.ts only
+ * - client.action.ts → client.domain.ts only
+ * - admin.action.ts → admin.domain.ts only
+ *
+ * This prevents mixing server-side and client-side logic.
+ */
+
+/**
+ * Cardinality constraint configurations.
+ * @type {import("eslint").Linter.Config[]}
+ */
+export const cardinalityConfigs = [
+  {
+    name: "cardinality/server-action",
+    files: ["**/actions/server.action.ts"],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["**/domain/client.domain*", "**/domain/admin.domain*"],
+              message:
+                "server.action can only import server.domain (cardinality violation)",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  {
+    name: "cardinality/client-action",
+    files: ["**/actions/client.action.ts"],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["**/domain/server.domain*", "**/domain/admin.domain*"],
+              message:
+                "client.action can only import client.domain (cardinality violation)",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  {
+    name: "cardinality/admin-action",
+    files: ["**/actions/admin.action.ts"],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["**/domain/server.domain*", "**/domain/client.domain*"],
+              message:
+                "admin.action can only import admin.domain (cardinality violation)",
+            },
+          ],
+        },
+      ],
+    },
+  },
+];

package/src/constants.mjs

@@ -0,0 +1,116 @@
+/**
+ * @fileoverview Shared constants and helpers for ESLint configuration.
+ */
+
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/** Find the project root by walking up from this package's location in node_modules */
+function findProjectRoot() {
+  let dir = __dirname;
+  while (dir !== path.dirname(dir)) {
+    if (
+      fs.existsSync(path.join(dir, "package.json")) &&
+      !dir.includes("/node_modules/")
+    ) {
+      return dir;
+    }
+    dir = path.dirname(dir);
+  }
+  return process.cwd();
+}
+
+const PROJECT_ROOT = findProjectRoot();
+
+/**
+ * Root directories containing feature modules.
+ * @type {string[]}
+ */
+export const FEATURE_ROOTS = [
+  "src/features",
+  "scripts/features",
+  "supabase/functions/features",
+];
+
+/**
+ * Files and directories to exclude from prefix mapping.
+ * @type {string[]}
+ */
+const EXCLUDE_LIST = ["proxy.ts", "types"];
+
+/**
+ * Generate PREFIX_LIB_MAPPING by scanning src/lib/ directory.
+ *
+ * @returns {Record<string, string>} Mapping of prefix to lib import path.
+ * @example
+ * - src/lib/supabase/server.ts → { server: "@/lib/supabase/server" }
+ * - src/lib/supabase/client.ts → { server: "@/lib/supabase/client" }
+ */
+function generatePrefixLibMapping() {
+  const libDir = path.join(PROJECT_ROOT, "src/lib");
+  const mapping = {};
+
+  if (!fs.existsSync(libDir)) {
+    return mapping;
+  }
+
+  const entries = fs.readdirSync(libDir, { withFileTypes: true });
+
+  for (const entry of entries) {
+    if (EXCLUDE_LIST.includes(entry.name)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      // Scan subdirectory (e.g., src/lib/supabase/)
+      const subDir = path.join(libDir, entry.name);
+      const subEntries = fs.readdirSync(subDir, { withFileTypes: true });
+
+      for (const subEntry of subEntries) {
+        if (
+          subEntry.isFile() &&
+          subEntry.name.endsWith(".ts") &&
+          !EXCLUDE_LIST.includes(subEntry.name)
+        ) {
+          const prefix = subEntry.name.replace(".ts", "");
+          mapping[prefix] = `@/lib/${entry.name}/${prefix}`;
+        }
+      }
+    } else if (entry.isFile() && entry.name.endsWith(".ts")) {
+      const prefix = entry.name.replace(".ts", "");
+      mapping[prefix] = `@/lib/${prefix}`;
+    }
+  }
+
+  return mapping;
+}
+
+/**
+ * Mapping of file prefixes to their corresponding lib imports.
+ *
+ * Dynamically generated by scanning src/lib/ directory.
+ * Used by:
+ * - naming.mjs: Validates file naming (e.g., server.repo.ts, client.repo.ts)
+ * - imports.mjs: Enforces import restrictions
+ *
+ * @example
+ * server.repo.ts → can only import @/lib/supabase/server
+ * client.repo.ts → can only import @/lib/supabase/client
+ *
+ * @type {Record<string, string>}
+ */
+export const PREFIX_LIB_MAPPING = generatePrefixLibMapping();
+
+/**
+ * Creates glob patterns for all feature roots.
+ * @param {string} subpath - The subpath to append to each feature root.
+ * @returns {string[]} Array of glob patterns.
+ * @example
+ * featuresGlob("**\/actions/*.ts")
+ * // => ["src/features/**\/actions/*.ts", "scripts/features/**\/actions/*.ts", ...]
+ */
+export const featuresGlob = (subpath) =>
+  FEATURE_ROOTS.map((root) => `${root}/${subpath}`);

package/src/directives.mjs

@@ -0,0 +1,72 @@
+/**
+ * @fileoverview Directive requirements for React Server Components.
+ *
+ * Ensures correct usage of "use server" and "use client" directives:
+ * - server.action.ts: Must start with "use server"
+ * - admin.action.ts: Must start with "use server"
+ * - client.action.ts: Must NOT have "use server"
+ * - hooks/*.ts: Must start with "use client"
+ */
+
+/**
+ * Directive requirement configurations.
+ * @type {import("eslint").Linter.Config[]}
+ */
+export const directivesConfigs = [
+  {
+    name: "directives/server-action",
+    files: ["src/features/**/actions/server.action.ts"],
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector:
+            "Program > :first-child:not(ExpressionStatement[expression.value='use server'])",
+          message: 'server.action.ts must start with "use server" directive.',
+        },
+      ],
+    },
+  },
+  {
+    name: "directives/admin-action",
+    files: ["src/features/**/actions/admin.action.ts"],
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector:
+            "Program > :first-child:not(ExpressionStatement[expression.value='use server'])",
+          message: 'admin.action.ts must start with "use server" directive.',
+        },
+      ],
+    },
+  },
+  {
+    name: "directives/client-action",
+    files: ["src/features/**/actions/client.action.ts"],
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector: "ExpressionStatement[expression.value='use server']",
+          message:
+            'client.action.ts must NOT have "use server" directive. It uses @/lib/supabase/client.',
+        },
+      ],
+    },
+  },
+  {
+    name: "directives/hooks",
+    files: ["src/features/**/hooks/*.ts"],
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector:
+            "Program > :first-child:not(ExpressionStatement[expression.value='use client'])",
+          message: 'Hooks must start with "use client" directive.',
+        },
+      ],
+    },
+  },
+];

package/src/imports.mjs

@@ -0,0 +1,58 @@
+/**
+ * @fileoverview Import restrictions for repository files.
+ *
+ * Enforces that each {prefix}.repo.ts can only import its corresponding lib:
+ * - server.repo.ts → @/lib/supabase/server only
+ * - client.repo.ts → @/lib/supabase/client only
+ *
+ * This prevents mixing different data sources in a single repository file.
+ */
+
+import { PREFIX_LIB_MAPPING } from "./constants.mjs";
+
+/**
+ * Generate import restriction configs for each prefix.
+ *
+ * For each prefix (e.g., "server"), creates a rule that forbids importing
+ * any other lib from PREFIX_LIB_MAPPING.
+ *
+ * @returns {import("eslint").Linter.Config[]}
+ */
+function generateImportConfigs() {
+  const prefixes = Object.keys(PREFIX_LIB_MAPPING);
+  const configs = [];
+
+  for (const prefix of prefixes) {
+    const allowedLib = PREFIX_LIB_MAPPING[prefix];
+    const forbiddenLibs = prefixes
+      .filter((p) => p !== prefix)
+      .map((p) => PREFIX_LIB_MAPPING[p]);
+
+    // Skip if no forbidden libs (shouldn't happen, but safety check)
+    if (forbiddenLibs.length === 0) continue;
+
+    configs.push({
+      name: `imports/${prefix}-repo`,
+      files: [`**/repositories/${prefix}.repo.ts`],
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          {
+            patterns: forbiddenLibs.map((lib) => ({
+              group: [`${lib}`, `${lib}/*`],
+              message: `${prefix}.repo.ts can only import from ${allowedLib}. Use the correct repository file for this lib.`,
+            })),
+          },
+        ],
+      },
+    });
+  }
+
+  return configs;
+}
+
+/**
+ * Import restriction configurations for repository files.
+ * @type {import("eslint").Linter.Config[]}
+ */
+export const importsConfigs = generateImportConfigs();

package/src/index.mjs

@@ -0,0 +1,36 @@
+/**
+ * @fileoverview Main ESLint configuration aggregator.
+ *
+ * Combines all configuration modules:
+ * - base: Next.js presets and shared rules
+ * - naming: File naming conventions
+ * - layers: Layer architecture constraints
+ * - cardinality: Action-domain relationships
+ * - directives: "use server" / "use client" requirements
+ * - imports: Repository import restrictions (prefix → lib mapping)
+ * - jsdoc: JSDoc description requirements for exported functions
+ */
+
+import { baseConfigs, ignoresConfig, sharedRulesConfig } from "./base.mjs";
+import { cardinalityConfigs } from "./cardinality.mjs";
+import { directivesConfigs } from "./directives.mjs";
+import { importsConfigs } from "./imports.mjs";
+import { jsdocConfigs } from "./jsdoc.mjs";
+import { layersConfigs } from "./layers.mjs";
+import { namingConfigs } from "./naming.mjs";
+
+/**
+ * Complete ESLint configuration array.
+ * @type {import("eslint").Linter.Config[]}
+ */
+export const eslintConfig = [
+  ...baseConfigs,
+  ignoresConfig,
+  sharedRulesConfig,
+  ...namingConfigs,
+  ...layersConfigs,
+  ...cardinalityConfigs,
+  ...directivesConfigs,
+  ...importsConfigs,
+  ...jsdocConfigs,
+];

package/src/jsdoc.mjs

@@ -0,0 +1,53 @@
+/**
+ * @fileoverview JSDoc configuration for the abstraction layer.
+ *
+ * Enforces a single rule: every exported function must have a description.
+ * Types are handled by TypeScript (machine layer), not JSDoc.
+ *
+ * Targets: repositories, domain, util.
+ * Excludes: actions, hooks, components, schemas, constants.
+ */
+
+import jsdocPlugin from "eslint-plugin-jsdoc";
+
+import { featuresGlob } from "./constants.mjs";
+
+/**
+ * JSDoc configurations requiring descriptions on exported functions.
+ * @type {import("eslint").Linter.Config[]}
+ */
+export const jsdocConfigs = [
+  {
+    name: "jsdoc",
+    files: [
+      ...featuresGlob("**/repositories/*.ts"),
+      ...featuresGlob("**/domain*/*.ts"),
+      ...featuresGlob("**/util*/*.ts"),
+    ],
+    plugins: {
+      jsdoc: jsdocPlugin,
+    },
+    rules: {
+      "jsdoc/require-jsdoc": [
+        "warn",
+        {
+          publicOnly: true,
+          require: {
+            FunctionDeclaration: true,
+            ArrowFunctionExpression: true,
+            FunctionExpression: true,
+          },
+          checkGetters: false,
+          checkSetters: false,
+          checkConstructors: false,
+        },
+      ],
+      "jsdoc/require-description": [
+        "warn",
+        {
+          contexts: ["any"],
+        },
+      ],
+    },
+  },
+];

package/src/layers.mjs

@@ -0,0 +1,160 @@
+/**
+ * @fileoverview Layer architecture constraints.
+ *
+ * Enforces the following dependency rules:
+ *
+ * Layer hierarchy (top to bottom):
+ *   hooks → actions → domain → repositories
+ *
+ * Rules:
+ * - Repositories: Cannot import domain, actions, or hooks.
+ *                 Cannot use try-catch or if statements.
+ * - Domain: Cannot import actions or hooks.
+ *            Cannot use try-catch.
+ * - Actions: Cannot import hooks.
+ *            Exported functions must start with "handle".
+ * - Hooks: Exported functions must start with "use".
+ *
+ * Cross-feature imports are also prohibited within the same layer.
+ */
+
+import { featuresGlob } from "./constants.mjs";
+
+/**
+ * Layer constraint configurations.
+ * @type {import("eslint").Linter.Config[]}
+ */
+export const layersConfigs = [
+  {
+    name: "layers/repositories",
+    files: ["**/repositories/*.ts"],
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector: "TryStatement",
+          message:
+            "try-catch is not allowed in repositories. Error handling belongs in actions.",
+        },
+        {
+          selector: "IfStatement",
+          message:
+            "if statements are not allowed in repositories. Conditional logic belongs in domain.",
+        },
+      ],
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["*/domain/*", "*/domain"],
+              message: "repositories cannot import domain (layer violation)",
+            },
+            {
+              group: ["*/actions/*", "*/actions"],
+              message: "repositories cannot import actions (layer violation)",
+            },
+            {
+              group: ["*/hooks/*", "*/hooks"],
+              message: "repositories cannot import hooks (layer violation)",
+            },
+            {
+              group: [
+                "@/features/*/repositories/*",
+                "@/features/*/repositories",
+              ],
+              message:
+                "repositories cannot import other feature's repositories (cross-feature violation)",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  {
+    name: "layers/domain",
+    files: ["**/domain/*.ts"],
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector: "TryStatement",
+          message:
+            "try-catch is not allowed in domain. Error handling belongs in actions.",
+        },
+      ],
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["*/actions/*", "*/actions"],
+              message: "domain cannot import actions (layer violation)",
+            },
+            {
+              group: ["*/hooks/*", "*/hooks"],
+              message: "domain cannot import hooks (layer violation)",
+            },
+            {
+              group: ["@/features/*/domain/*", "@/features/*/domain"],
+              message:
+                "domain cannot import other feature's domain (cross-feature violation)",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  {
+    name: "layers/actions-naming",
+    files: featuresGlob("**/actions/*.ts"),
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector:
+            "ExportNamedDeclaration > FunctionDeclaration[id.name!=/^handle[A-Z]/]",
+          message:
+            "Exported functions in actions must start with 'handle' (e.g., handleGetComics).",
+        },
+      ],
+    },
+  },
+  {
+    name: "layers/actions-imports",
+    files: ["**/actions/*.ts"],
+    rules: {
+      "no-restricted-imports": [
+        "error",
+        {
+          patterns: [
+            {
+              group: ["*/hooks/*", "*/hooks"],
+              message: "actions cannot import hooks (layer violation)",
+            },
+            {
+              group: ["@/features/*/actions/*", "@/features/*/actions"],
+              message:
+                "actions cannot import other feature's actions (cross-feature violation)",
+            },
+          ],
+        },
+      ],
+    },
+  },
+  {
+    name: "layers/hooks-naming",
+    files: featuresGlob("**/hooks/*.ts"),
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector:
+            "ExportNamedDeclaration > FunctionDeclaration[id.name!=/^use[A-Z]/]",
+          message:
+            "Exported functions in hooks must start with 'use' (e.g., useAuth).",
+        },
+      ],
+    },
+  },
+];

package/src/naming.mjs

@@ -0,0 +1,194 @@
+/**
+ * @fileoverview File naming conventions for feature modules.
+ *
+ * Enforces consistent naming patterns:
+ * - domain: {prefix}.domain.ts (e.g., server.domain.ts, stripe.domain.ts)
+ * - repositories: {prefix}.repo.ts (e.g., server.repo.ts, stripe.repo.ts)
+ * - actions: {prefix}.action.ts (e.g., server.action.ts, stripe.action.ts)
+ * - hooks: useXxx.ts (e.g., useAuth.ts)
+ * - types: {feature}.type.ts (e.g., threads.type.ts) — shared: free naming
+ * - schemas: xxx.schema.ts (e.g., comic.schema.ts)
+ * - util: {feature}.util.ts (e.g., threads.util.ts) — shared: free naming
+ * - constants: xxx.constant.ts (e.g., api.constant.ts)
+ *
+ * Extension constraints:
+ * - features/**: .ts only (no .tsx — components belong in src/components/)
+ * - components/**:  .tsx only (no .ts — logic belongs in src/features/)
+ *
+ * Component naming:
+ * - components/ *.tsx: PascalCase (e.g., Button.tsx, AlertDialog.tsx)
+ * - components/shared/ui/ : excluded (shadcn/ui uses kebab-case)
+ *
+ * Valid prefixes are defined in PREFIX_LIB_MAPPING (constants.mjs).
+ */
+
+import { featuresGlob, PREFIX_LIB_MAPPING } from "./constants.mjs";
+import { checkFile } from "./plugins.mjs";
+
+/**
+ * Generate glob pattern from PREFIX_LIB_MAPPING keys.
+ * @example "@(server|client|admin)"
+ */
+const prefixPattern = `@(${Object.keys(PREFIX_LIB_MAPPING).join("|")})`;
+
+/**
+ * File naming convention configurations.
+ * @type {import("eslint").Linter.Config[]}
+ */
+export const namingConfigs = [
+  {
+    name: "naming/domain",
+    files: featuresGlob("**/domain/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.ts": `${prefixPattern}.domain` },
+      ],
+    },
+  },
+  {
+    name: "naming/repositories",
+    files: featuresGlob("**/repositories/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.ts": `${prefixPattern}.repo` },
+      ],
+    },
+  },
+  {
+    name: "naming/hooks",
+    files: featuresGlob("**/hooks/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.ts": "use[A-Z]*([a-zA-Z0-9])" },
+        { ignoreMiddleExtensions: true },
+      ],
+    },
+  },
+  {
+    name: "naming/types",
+    files: featuresGlob("*/types/*.type.ts"),
+    ignores: featuresGlob("shared/types/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*/types/*.ts": "<1>" },
+        { ignoreMiddleExtensions: true },
+      ],
+    },
+  },
+  {
+    name: "naming/types-shared",
+    files: featuresGlob("shared/types/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.ts": "+([a-z0-9_-]).type" },
+      ],
+    },
+  },
+  {
+    name: "naming/schemas",
+    files: featuresGlob("**/schemas/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.ts": "+([a-z0-9-]).schema" },
+      ],
+    },
+  },
+  {
+    name: "naming/util",
+    files: featuresGlob("*/util/*.util.ts"),
+    ignores: featuresGlob("shared/util/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*/util/*.ts": "<1>" },
+        { ignoreMiddleExtensions: true },
+      ],
+    },
+  },
+  {
+    name: "naming/util-shared",
+    files: featuresGlob("shared/util/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.ts": "+([a-z0-9_-]).util" },
+      ],
+    },
+  },
+  {
+    name: "naming/constants",
+    files: featuresGlob("**/constants/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.ts": "+([a-z0-9-]).constant" },
+      ],
+    },
+  },
+  {
+    name: "naming/actions",
+    files: featuresGlob("**/actions/*.ts"),
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.ts": `${prefixPattern}.action` },
+      ],
+    },
+  },
+  {
+    name: "naming/features-ts-only",
+    files: featuresGlob("**/*.tsx"),
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector: "Program",
+          message:
+            "features/ must only contain .ts files. Components belong in src/components/.",
+        },
+      ],
+    },
+  },
+  {
+    name: "naming/components-tsx-only",
+    files: ["src/components/**/*.ts"],
+    rules: {
+      "no-restricted-syntax": [
+        "error",
+        {
+          selector: "Program",
+          message:
+            "components/ must only contain .tsx files. Logic belongs in src/features/.",
+        },
+      ],
+    },
+  },
+  {
+    name: "naming/components-pascal-case",
+    files: ["src/components/**/*.tsx"],
+    ignores: ["src/components/shared/ui/**"],
+    plugins: { "check-file": checkFile },
+    rules: {
+      "check-file/filename-naming-convention": [
+        "error",
+        { "**/*.tsx": "PASCAL_CASE" },
+      ],
+    },
+  },
+];

package/src/plugins.mjs

@@ -0,0 +1,29 @@
+/**
+ * @fileoverview ESLint plugin imports and exports.
+ */
+
+import stylistic from "@stylistic/eslint-plugin";
+import checkFile from "eslint-plugin-check-file";
+import jsdocPlugin from "eslint-plugin-jsdoc";
+import reactYouMightNotNeedAnEffect from "eslint-plugin-react-you-might-not-need-an-effect";
+import simpleImportSortPlugin from "eslint-plugin-simple-import-sort";
+
+/**
+ * Plugin namespace mapping for ESLint configuration.
+ * @type {Record<string, import("eslint").ESLint.Plugin>}
+ */
+export const plugins = {
+  "@stylistic": stylistic,
+  "check-file": checkFile,
+  jsdoc: jsdocPlugin,
+  "react-you-might-not-need-an-effect": reactYouMightNotNeedAnEffect,
+  "simple-import-sort": simpleImportSortPlugin,
+};
+
+export {
+  checkFile,
+  jsdocPlugin,
+  reactYouMightNotNeedAnEffect,
+  simpleImportSortPlugin,
+  stylistic,
+};