@yasainet/eslint 0.0.73 → 0.0.75

package/src/common/layers/services.mjs

@@ -0,0 +1,121 @@
+import { featuresGlob } from "../_internal/constants.mjs";
+import { LIB_BOUNDARY_PATTERNS } from "../_internal/import-patterns.mjs";
+import { checkFile } from "../_internal/plugins.mjs";
+import {
+  aliasDynamicImportMessage,
+  aliasDynamicImportSelector,
+  loggerMessage,
+  loggerSelector,
+} from "../_internal/selectors.mjs";
+
+const LAYER_PATTERNS = [
+  {
+    group: ["**/entries/*", "**/entries"],
+    message: "services は entries を import 不可。依存は単方向に保つ。",
+  },
+  {
+    group: ["**/hooks/*", "**/hooks"],
+    message: "services は hooks を import 不可。依存は単方向に保つ。",
+  },
+];
+
+const LATERAL_PATTERNS = [
+  {
+    group: ["@/features/*/services/*", "@/features/*/services"],
+    message:
+      "他 feature の services は import 不可。feature を跨ぐ依存は禁止。",
+  },
+];
+
+export function createServicesConfigs({ featureRoot, prefixLibMapping }) {
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const prefixPattern = hasPrefixes ? `@(${prefixes.join("|")})` : "*";
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
+
+  return [
+    {
+      name: "naming/services",
+      files: featuresGlob(featureRoot, "**/services/*.ts"),
+      ignores: [
+        ...featuresGlob(featureRoot, "shared/services/*.ts"),
+        "**/*.test.ts",
+      ],
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": prefixPattern },
+        ],
+      },
+    },
+    {
+      name: "naming/services-shared",
+      files: featuresGlob(featureRoot, "shared/services/*.ts"),
+      ignores: ["**/*.test.ts"],
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": sharedPrefixPattern },
+        ],
+      },
+    },
+    {
+      name: "layers/services",
+      files: [`${featureRoot}/**/services/*.ts`],
+      rules: {
+        "no-restricted-syntax": [
+          "error",
+          {
+            selector: "TryStatement",
+            message:
+              "services で try-catch は禁止。エラー処理は entries に集約する。",
+          },
+          {
+            selector: "ThrowStatement",
+            message:
+              "services で throw は禁止。失敗は値で返す:\n" +
+              "- `T | null` / `{ data, error }` / 空デフォルトのいずれか\n" +
+              "- lib の native 例外は entry の catch に自動伝播する",
+          },
+          { selector: loggerSelector, message: loggerMessage },
+          {
+            selector:
+              "LogicalExpression[operator='??'][left.type='ChainExpression'][left.expression.property.name='message'][right.type='Literal']",
+            message:
+              "error message の dead fallback。この分岐に来た時点で error は既知 — error をそのまま返す。",
+          },
+          {
+            selector:
+              "LogicalExpression[operator='??'][left.type='MemberExpression'][left.property.name='error'][right.type='ObjectExpression']",
+            message:
+              "nullable error の dead fallback。`if (error)` で判定し error をそのまま返す。",
+          },
+          {
+            selector: aliasDynamicImportSelector,
+            message: aliasDynamicImportMessage,
+          },
+        ],
+      },
+    },
+    {
+      name: "imports/services",
+      files: [`${featureRoot}/**/services/*.ts`],
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          {
+            patterns: [
+              ...LAYER_PATTERNS,
+              ...LATERAL_PATTERNS,
+              ...LIB_BOUNDARY_PATTERNS,
+            ],
+          },
+        ],
+      },
+    },
+  ];
+}

package/src/common/layers/top-level-utils.mjs

@@ -0,0 +1,18 @@
+import { checkFile } from "../_internal/plugins.mjs";
+
+export function createTopLevelUtilsConfigs({ featureRoot }) {
+  const utilsRoot = featureRoot.replace(/features$/, "utils");
+  return [
+    {
+      name: "naming/top-level-utils",
+      files: [`${utilsRoot}/**/*.ts`],
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": "*" },
+        ],
+      },
+    },
+  ];
+}

package/src/common/layers/types.mjs

@@ -0,0 +1,44 @@
+import { featuresGlob } from "../_internal/constants.mjs";
+import { MAPPING_PATTERNS } from "../_internal/import-patterns.mjs";
+import { checkFile } from "../_internal/plugins.mjs";
+
+export function createTypesConfigs({ featureRoot, prefixLibMapping }) {
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
+
+  return [
+    {
+      name: "naming/types",
+      files: featuresGlob(featureRoot, "*/types/*.ts"),
+      ignores: featuresGlob(featureRoot, "shared/types/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*/types/*.ts": "<1>" },
+        ],
+      },
+    },
+    {
+      name: "naming/types-shared",
+      files: featuresGlob(featureRoot, "shared/types/*.ts"),
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": sharedPrefixPattern },
+        ],
+      },
+    },
+    {
+      name: "imports/feature-types",
+      files: [`${featureRoot}/**/types/*.ts`],
+      rules: {
+        "no-restricted-imports": ["error", { patterns: MAPPING_PATTERNS }],
+      },
+    },
+  ];
+}

package/src/common/layers/utils.mjs

@@ -0,0 +1,54 @@
+import { featuresGlob } from "../_internal/constants.mjs";
+import {
+  LIB_BOUNDARY_PATTERNS,
+  MAPPING_PATTERNS,
+} from "../_internal/import-patterns.mjs";
+import { checkFile } from "../_internal/plugins.mjs";
+
+export function createUtilsConfigs({ featureRoot, prefixLibMapping }) {
+  const prefixes = Object.keys(prefixLibMapping);
+  const hasPrefixes = prefixes.length > 0;
+  const sharedPrefixPattern = hasPrefixes
+    ? `@(shared|${prefixes.join("|")})`
+    : "shared";
+
+  return [
+    {
+      name: "naming/utils",
+      files: featuresGlob(featureRoot, "*/utils/*.ts"),
+      ignores: [
+        ...featuresGlob(featureRoot, "shared/utils/*.ts"),
+        "**/*.test.ts",
+      ],
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*/utils/*.ts": "<1>" },
+        ],
+      },
+    },
+    {
+      name: "naming/utils-shared",
+      files: featuresGlob(featureRoot, "shared/utils/*.ts"),
+      ignores: ["**/*.test.ts"],
+      plugins: { "check-file": checkFile },
+      rules: {
+        "check-file/filename-naming-convention": [
+          "error",
+          { "**/*.ts": sharedPrefixPattern },
+        ],
+      },
+    },
+    {
+      name: "imports/utils",
+      files: [`${featureRoot}/**/utils/*.ts`],
+      rules: {
+        "no-restricted-imports": [
+          "error",
+          { patterns: [...LIB_BOUNDARY_PATTERNS, ...MAPPING_PATTERNS] },
+        ],
+      },
+    },
+  ];
+}

package/src/common/local-plugins/entry-single-service-call.mjs

@@ -1,33 +1,3 @@
-/**
- * Enforce 1:1 entry-to-service mapping for `**\/entries/*.ts` exports.
- *
- * Why: services are the orchestration layer (they may combine multiple queries
- * and other features' queries). entries should be a thin wrapper that calls a
- * single service function and normalizes the return shape into
- * `{ data, error }`. If an entry calls more than one service, orchestration is
- * leaking up into the entry layer.
- *
- * Detection rule:
- *
- * - For every exported async `FunctionDeclaration` in an entries file, count
- *   `CallExpression`s whose callee is a `MemberExpression` of the form
- *   `<binding>.<method>(...)` where `<binding>` matches the namespace import
- *   naming convention `*Service` (e.g. `articlesServerService`,
- *   `usersClientService`).
- * - More than one such call inside the same exported function is an error.
- *
- * Exception (C-3):
- *
- * - Bindings starting with `shared` (e.g. `sharedDiscordService`,
- *   `sharedResendService`) are EXCLUDED from the count. These represent
- *   cross-cutting side-effect abstractions (Discord / Resend / Slack
- *   notifications) that don't fit the entry-service 1:1 model and are allowed
- *   to be invoked from entries directly.
- *
- * The rule reports the 2nd and later violations (the 1st call is permitted),
- * so the fix surface is the redundant calls.
- */
-
 const SERVICE_BINDING_REGEX = /Service$/;
 
 function isServiceCall(node) {
@@ -69,7 +39,9 @@ export const entrySingleServiceCallRule = {
     },
     messages: {
       multipleServiceCalls:
-        "entry '{{ funcName }}' calls more than one feature service ({{ count }} total). entries must be a thin wrapper that calls a single service. Move orchestration into the service layer. `shared/services/*` (e.g. `sharedDiscordService`) is exempt.",
+        "entry '{{ funcName }}' が複数の feature service を呼んでいる ({{ count }} 件):\n" +
+        "- entry は単一 service を呼ぶ薄いラッパー、orchestration は service 層へ移す\n" +
+        "- `shared/services/*` (例 `sharedDiscordService`) は例外",
     },
     schema: [],
   },

package/src/common/local-plugins/entry-template.mjs

@@ -1,58 +1,12 @@
-/**
- * Enforce the canonical entry template for `**\/entries/*.ts` exports.
- *
- * Two body shapes are accepted:
- *
- * - **Pattern A** (read / mutation entries): body is a single try/catch.
- * - **Pattern B** (redirect entries): body contains exactly one try/catch and
- *   ends with a terminal Next.js navigation call (`redirect`, `notFound`,
- *   `permanentRedirect`) — placed *outside* try/catch per the Next.js docs,
- *   since these helpers throw `NEXT_REDIRECT` / `NEXT_NOT_FOUND` and must not
- *   be intercepted by the entry's own catch. Pattern B does not require a
- *   `return { data, error: null }` in the try block (success is the redirect).
- *
- * Both patterns share the same try/catch contract:
- *
- * - try first statement: `logger.info(<obj>, "Start <funcName>")`
- * - try success return preceded by: `logger.info(<obj>, "Success <funcName>")`
- *   (Pattern A only — Pattern B's success path terminates via redirect)
- * - try failed branch (when present): `logger.error(<obj>, "Failed <funcName>")`
- *   followed by a return with the proper error shape
- * - catch param: `error: unknown`
- * - catch first statement: `logger.error(<obj>, "Unexpected error in <funcName>")`
- * - catch return error.message must be the literal "An unexpected error occurred"
- * - every log object must include the `err` key first (when applicable) and
- *   propagate all function input parameters as values
- *
- * Why one rule with many messageIds: each invariant is a small rule
- * conceptually, but they share the same structural traversal and access to
- * funcName / inputArgs. Splitting would duplicate the AST walk.
- */
-
 const CATCH_RETURN_MESSAGE = "An unexpected error occurred";
-const TERMINAL_CALLEES = new Set([
-  "redirect",
-  "permanentRedirect",
-  "notFound",
-]);
+const TERMINAL_CALLEES = new Set(["redirect", "permanentRedirect", "notFound"]);
 
-/**
- * Param identifier names that are excluded from log propagation. These hold
- * secrets that must never be written to logs (Vercel logs are forwarded to
- * external drains, so treating them as sensitive is the conservative default).
- */
 const REDACT_PARAM_NAMES = new Set([
   "password",
   "newPassword",
   "currentPassword",
 ]);
 
-/**
- * Param TypeScript type names that are excluded from log propagation. Supabase
- * credential types contain `password` as a field; logging the whole param leaks
- * the secret. Listed types are matched on the type annotation's identifier
- * name (no type-info resolution; aliases must match by name).
- */
 const REDACT_PARAM_TYPES = new Set([
   "SignUpWithPasswordCredentials",
   "SignInWithPasswordCredentials",
@@ -91,7 +45,8 @@ function isLoggerCall(node, level) {
 
 function getStringLiteralArg(callExpr, index) {
   const arg = callExpr.arguments[index];
-  if (arg?.type === "Literal" && typeof arg.value === "string") return arg.value;
+  if (arg?.type === "Literal" && typeof arg.value === "string")
+    return arg.value;
   return null;
 }
 
@@ -112,7 +67,10 @@ function objectContainsValue(objExpr, identifierName) {
     ) {
       return true;
     }
-    if (prop.value.type === "Identifier" && prop.value.name === identifierName) {
+    if (
+      prop.value.type === "Identifier" &&
+      prop.value.name === identifierName
+    ) {
       return true;
     }
   }
@@ -124,10 +82,10 @@ function firstPropertyIsErrKey(objExpr, errorIdentifierName) {
   const first = objExpr.properties[0];
   if (first.type !== "Property") return false;
   if (first.key.type !== "Identifier" || first.key.name !== "err") return false;
-  // value must be the catch error identifier (or any Identifier — we accept both
-  // `err: error` and `err: result.error` since Failed Pattern C uses MemberExpression)
   if (first.value.type === "Identifier") {
-    return errorIdentifierName ? first.value.name === errorIdentifierName : true;
+    return errorIdentifierName
+      ? first.value.name === errorIdentifierName
+      : true;
   }
   if (first.value.type === "MemberExpression") return true;
   return false;
@@ -201,7 +159,6 @@ function checkLogCall({
 }
 
 function isReturnDataErrorNull(ret) {
-  // `return { data: ..., error: null }` (data shorthand or explicit)
   const arg = ret.argument;
   if (arg?.type !== "ObjectExpression") return false;
   let hasData = false;
@@ -230,8 +187,12 @@ function getReturnErrorMessageLiteral(ret) {
     if (prop.value.type !== "ObjectExpression") return null;
     for (const inner of prop.value.properties) {
       if (inner.type !== "Property") continue;
-      if (inner.key.type !== "Identifier" || inner.key.name !== "message") continue;
-      if (inner.value.type === "Literal" && typeof inner.value.value === "string") {
+      if (inner.key.type !== "Identifier" || inner.key.name !== "message")
+        continue;
+      if (
+        inner.value.type === "Literal" &&
+        typeof inner.value.value === "string"
+      ) {
         return inner.value.value;
       }
       return "<non-literal>";
@@ -283,7 +244,6 @@ function endsWithTerminal(node) {
 }
 
 function caseEndsWithTerminal(switchCase, allCases, idx) {
-  // Empty consequent = fallthrough; inherit next case's terminator.
   if (switchCase.consequent.length === 0) {
     const next = allCases[idx + 1];
     if (!next) return false;
@@ -311,11 +271,14 @@ function classifyBody(body) {
 
 function checkTryBlock(context, tryBlock, funcName, inputArgNames, options) {
   if (tryBlock.body.length === 0) {
-    context.report({ node: tryBlock, messageId: "tryEmpty", data: { funcName } });
+    context.report({
+      node: tryBlock,
+      messageId: "tryEmpty",
+      data: { funcName },
+    });
     return;
   }
 
-  // Start log: first statement
   const first = tryBlock.body[0];
   if (!isExpressionStatementWithLoggerCall(first, "info")) {
     context.report({
@@ -337,16 +300,12 @@ function checkTryBlock(context, tryBlock, funcName, inputArgNames, options) {
     });
   }
 
-  // Walk body to find Success returns and Failed branches
   let successFound = false;
   for (let i = 0; i < tryBlock.body.length; i++) {
     const stmt = tryBlock.body[i];
 
-    // Success log + return
     if (stmt.type === "ReturnStatement" && isReturnDataErrorNull(stmt)) {
       successFound = true;
-      // The previous non-ExpressionStatement non-IfStatement statement should be
-      // the Success log. Walk back to find it.
       const prev = findPrecedingLoggerCall(tryBlock.body, i);
       if (
         !prev ||
@@ -373,7 +332,6 @@ function checkTryBlock(context, tryBlock, funcName, inputArgNames, options) {
       }
     }
 
-    // Failed branches inside if statements
     if (stmt.type === "IfStatement") {
       checkFailedBranch(context, stmt, funcName, inputArgNames);
     }
@@ -396,7 +354,6 @@ function findPrecedingLoggerCall(body, returnIndex) {
       s.type === "ExpressionStatement" &&
       s.expression.type === "AwaitExpression"
     ) {
-      // `await revalidatePath(...)` etc — keep walking
       continue;
     }
     if (s.type === "ExpressionStatement") {
@@ -409,16 +366,13 @@ function findPrecedingLoggerCall(body, returnIndex) {
 }
 
 function checkFailedBranch(context, ifStmt, funcName, inputArgNames) {
-  // We only validate IFs that look like Failed branches: contain a return whose
-  // error.message is a string literal (not the catch's "An unexpected ..." literal).
   const consequent = ifStmt.consequent;
   if (consequent.type !== "BlockStatement") return;
   const ret = consequent.body.find((s) => s.type === "ReturnStatement");
   if (!ret) return;
   const errMsg = getReturnErrorMessageLiteral(ret);
-  if (errMsg === null) return; // not a Failed-shaped return; skip
+  if (errMsg === null) return;
 
-  // Must have logger.error("Failed <funcName>") preceding the return
   const idx = consequent.body.indexOf(ret);
   let loggerCall = null;
   for (let j = 0; j < idx; j++) {
@@ -440,7 +394,7 @@ function checkFailedBranch(context, ifStmt, funcName, inputArgNames) {
     return;
   }
 
-  const isPatternC = errMsg === "<non-literal>"; // .message access
+  const isPatternC = errMsg === "<non-literal>";
   checkLogCall({
     context,
     callExpr: loggerCall,
@@ -471,7 +425,11 @@ function checkCatchClause(context, handler, funcName, inputArgNames) {
   }
   const block = handler.body;
   if (block.body.length === 0) {
-    context.report({ node: block, messageId: "catchEmpty", data: { funcName } });
+    context.report({
+      node: block,
+      messageId: "catchEmpty",
+      data: { funcName },
+    });
     return;
   }
   const first = block.body[0];
@@ -495,7 +453,6 @@ function checkCatchClause(context, handler, funcName, inputArgNames) {
     });
   }
 
-  // Last statement must be a return whose error.message is the catch literal
   const last = block.body[block.body.length - 1];
   if (last?.type !== "ReturnStatement") {
     context.report({
@@ -510,7 +467,11 @@ function checkCatchClause(context, handler, funcName, inputArgNames) {
     context.report({
       node: last,
       messageId: "catchWrongReturnMessage",
-      data: { funcName, expected: CATCH_RETURN_MESSAGE, actual: msg ?? "<missing>" },
+      data: {
+        funcName,
+        expected: CATCH_RETURN_MESSAGE,
+        actual: msg ?? "<missing>",
+      },
     });
   }
 }
@@ -524,35 +485,37 @@ export const entryTemplateRule = {
     },
     messages: {
       bodyNotTryCatch:
-        "entry '{{ funcName }}' body must be either a single try/catch (Pattern A) or a try/catch followed by a terminal navigation call such as `redirect(...)` / `notFound(...)` (Pattern B).",
-      tryEmpty: "entry '{{ funcName }}' try block is empty.",
+        "entry '{{ funcName }}' の body は次のいずれか:\n" +
+        "- 単一の try/catch (Pattern A)\n" +
+        "- try/catch + 末尾の navigation 呼び出し `redirect(...)` / `notFound(...)` (Pattern B)",
+      tryEmpty: "entry '{{ funcName }}' の try block が空。",
       tryMissingStartLog:
-        "entry '{{ funcName }}' try block must start with `logger.info(<obj>, \"Start {{ funcName }}\")`.",
+        "entry '{{ funcName }}' の try block は `logger.info(<obj>, \"Start {{ funcName }}\")` で始める。",
       trySuccessLogMissing:
-        "entry '{{ funcName }}' success return must be preceded by `logger.info(<obj>, \"Success {{ funcName }}\")`.",
+        "entry '{{ funcName }}' の success return の直前に `logger.info(<obj>, \"Success {{ funcName }}\")` が必須。",
       trySuccessReturnMissing:
-        "entry '{{ funcName }}' must contain a success return `return { data, error: null }`.",
+        "entry '{{ funcName }}' は success return `return { data, error: null }` が必須。",
       failedLogMissing:
-        "entry '{{ funcName }}' Failed branch must call `logger.error(<obj>, \"Failed {{ funcName }}\")` before return.",
+        "entry '{{ funcName }}' の Failed 分岐は return 前に `logger.error(<obj>, \"Failed {{ funcName }}\")` を呼ぶ。",
       catchParamWrongType:
-        "entry '{{ funcName }}' catch param must be `error: unknown`.",
-      catchEmpty: "entry '{{ funcName }}' catch block is empty.",
+        "entry '{{ funcName }}' の catch param は `error: unknown`。",
+      catchEmpty: "entry '{{ funcName }}' の catch block が空。",
       catchMissingErrorLog:
-        "entry '{{ funcName }}' catch block must start with `logger.error(<obj>, \"Unexpected error in {{ funcName }}\")`.",
+        "entry '{{ funcName }}' の catch block は `logger.error(<obj>, \"Unexpected error in {{ funcName }}\")` で始める。",
       catchLastNotReturn:
-        "entry '{{ funcName }}' catch block must end with a return statement.",
+        "entry '{{ funcName }}' の catch block は return 文で終える。",
       catchWrongReturnMessage:
-        "entry '{{ funcName }}' catch return error.message must be the literal '{{ expected }}'. Got: '{{ actual }}'.",
+        "entry '{{ funcName }}' の catch return の error.message はリテラル '{{ expected }}'。実際: '{{ actual }}'。",
       logWrongCallShape:
-        "{{ where }} log in '{{ funcName }}' must be `logger.{{ expectedLevel }}(<obj>, \"{{ expectedMessage }}\")`.",
+        "'{{ funcName }}' の {{ where }} log は `logger.{{ expectedLevel }}(<obj>, \"{{ expectedMessage }}\")`。",
       logWrongMessage:
-        "{{ where }} log message must be '{{ expectedMessage }}'. Got: '{{ actual }}'.",
+        "{{ where }} log message は '{{ expectedMessage }}'。実際: '{{ actual }}'。",
       logFirstArgNotObject:
-        "{{ where }} log in '{{ funcName }}' first argument must be an object literal.",
+        "'{{ funcName }}' の {{ where }} log の第1引数は object literal にする。",
       logErrKeyNotFirst:
-        "{{ where }} log in '{{ funcName }}' object must start with `err:` key.",
+        "'{{ funcName }}' の {{ where }} log object は `err:` キーで始める。",
       logMissingInputArg:
-        "{{ where }} log in '{{ funcName }}' is missing input arg '{{ argName }}'. All function inputs must propagate to log objects.",
+        "'{{ funcName }}' の {{ where }} log に入力引数 '{{ argName }}' が無い。全ての関数入力を log object に伝播する。",
     },
     schema: [],
   },

package/src/common/local-plugins/feature-name.mjs

@@ -1,11 +1,6 @@
 import fs from "fs";
 import path from "path";
 
-/**
- * Extract table names from Supabase generated types file.
- * Looks for top-level keys under `Tables: {` inside the `public` schema.
- * Uses brace counting to handle deeply nested type definitions.
- */
 function extractTableNames(supabaseTypePath) {
   if (!fs.existsSync(supabaseTypePath)) {
     return [];
@@ -13,7 +8,6 @@ function extractTableNames(supabaseTypePath) {
 
   const content = fs.readFileSync(supabaseTypePath, "utf-8");
 
-  // Find `public:` excluding `graphql_public:` via negative lookbehind
   const publicMatch = /(?<!\w)public:\s*\{/.exec(content);
   if (!publicMatch) {
     return [];
@@ -25,13 +19,11 @@ function extractTableNames(supabaseTypePath) {
     return [];
   }
 
-  // Find the opening brace of `Tables: {`
   const braceStart = content.indexOf("{", tablesIdx + tablesLabel.length);
   if (braceStart === -1) {
     return [];
   }
 
-  // Extract the Tables block using brace counting
   let depth = 0;
   let blockEnd = -1;
   for (let i = braceStart; i < content.length; i++) {
@@ -46,14 +38,12 @@ function extractTableNames(supabaseTypePath) {
     return [];
   }
 
-  // Extract top-level keys (depth 0) inside the Tables block
   const tablesBlock = content.slice(braceStart + 1, blockEnd);
   const names = [];
   depth = 0;
   const keyRegex = /(\w+)\s*:/g;
   let match;
   while ((match = keyRegex.exec(tablesBlock)) !== null) {
-    // Count braces before this match to determine depth
     const preceding = tablesBlock.slice(0, match.index);
     let d = 0;
     for (const ch of preceding) {
@@ -67,21 +57,16 @@ function extractTableNames(supabaseTypePath) {
   return names;
 }
 
-/** Convert snake_case to kebab-case. */
 function toKebab(name) {
   return name.replace(/_/g, "-");
 }
 
-/**
- * Enforce that feature directory names match allowed values:
- * "shared", "auth", plus Supabase table names converted to kebab-case.
- */
 export const featureNameRule = {
   meta: {
     type: "problem",
     messages: {
       invalidFeatureName:
-        "Feature directory '{{ name }}' is not allowed. Allowed: {{ allowed }}.",
+        "feature directory '{{ name }}' は許可されない。許可: {{ allowed }}。",
     },
     schema: [
       {
@@ -107,15 +92,11 @@ export const featureNameRule = {
     if (!featureName) return {};
 
     const projectRoot = filename.slice(0, rootIdx).replace(/\/src$/, "");
-    // Prefer the Supabase types file adjacent to `featureRoot` (e.g. `src/lib/...`
-    // for `src/features`). Fall back to `src/lib/...` at the project root so that
-    // non-`src` feature roots (e.g. `scripts/features`) can reuse the same
-    // generated types without duplicating the file. Both `types.ts` (plural) and
-    // `type.ts` (singular) are accepted to match either naming convention.
     const candidateTypePaths = [
-      path.join(projectRoot, featureRoot.replace(/features$/, "lib/supabase/types.ts")),
-      path.join(projectRoot, featureRoot.replace(/features$/, "lib/supabase/type.ts")),
-      path.join(projectRoot, "src/lib/supabase/types.ts"),
+      path.join(
+        projectRoot,
+        featureRoot.replace(/features$/, "lib/supabase/type.ts"),
+      ),
       path.join(projectRoot, "src/lib/supabase/type.ts"),
     ];
     const supabaseTypePath =