mm_eslint 1.0.7 → 1.0.9

package/README.md

@@ -17,6 +17,7 @@
 - ✅ **单词长度限制** - 每个单词限制在最大8字符
 - ✅ **禁止废话词** - 避免使用Manager、Handler等冗余词汇
 - ✅ **JSDoc支持** - 集成JSDoc文档要求
+- ✅ **命名推荐功能** - 推荐更短的替代名称，同时保持语义不变
 
 ## 安装
 
@@ -268,8 +269,98 @@ const customConfig = {
 };
 
 const detector = new NamingDetector(customConfig);
+
+## 命名推荐功能
+
+插件包含智能命名推荐系统，建议使用更短的替代名称，同时保持语义不变。
+
+### 核心原则
+
+核心原则是**"缩短命名而不改变语义"**。推荐系统：
+- 推荐更短的单词，同时保持相同含义
+- 避免会改变功能的概念性变化
+- 确保推荐词始终比原词短
+- 保留编程特定术语和概念差异
+
+### 配置
+
+在ESLint配置中启用推荐功能：
+
+```javascript
+// eslint.config.js
+const namingConventionPlugin = require("mm_eslint");
+
+module.exports = [
+  {
+    files: ["**/*.js"],
+    plugins: {
+      "naming-convention": namingConventionPlugin,
+    },
+    rules: {
+      "naming-convention/class-name": "error",
+      "naming-convention/function-name": ["error", { recommen: true }], // 启用推荐功能
+      // ... 其他规则
+    },
+  },
+];
+```
+
+### 可用推荐
+
+插件为常见编程操作提供推荐：
+
+| 原词 | 推荐词 | 描述 |
+|------|--------|------|
+| `calculate` | `calc` | 数学运算 |
+| `generate` | `gen` | 数据生成 |
+| `initialize` | `init` | 初始化操作 |
+| `execute` | `exec` | 命令执行 |
+| `process` | `run` | 数据处理 |
+| `retrieve` | `load` | 数据加载 |
+| `persist` | `save` | 数据存储 |
+| `compare` | `cmp` | 比较操作 |
+| `duplicate` | `copy` | 数据复制 |
+| `transfer` | `move` | 数据移动 |
+| `convert` | `to` | 类型转换 |
+| `verify` | `check` | 验证检查 |
+| `construct` | `create` | 对象创建 |
+| `handle` | `run` | 事件处理 |
+
+### 示例
+
+```javascript
+// ❌ 原词（较长名称）
+function calculateTotal() {}
+function generateUserData() {}
+function initializeSystem() {}
+function executeCommand() {}
+function processData() {}
+
+// ✅ 推荐词（较短名称）
+function calcTotal() {}
+function genUserData() {}
+function initSystem() {}
+function execCommand() {}
+function runData() {}
+```
+
+### 带推荐的错误消息
+
+启用推荐功能后，ESLint将建议替代名称：
+
+```bash
+# ESLint输出示例
+function calculateTotal() {}
+# ^ 建议使用'calc'替代'calculate'以获得更短的命名
 ```
 
+### 优势
+
+1. **提高可读性**：更短的名称更容易阅读和理解
+2. **一致的代码库**：项目中的标准化命名
+3. **语义保持**：在减少冗长的同时保持含义
+4. **编程最佳实践**：遵循简洁命名的行业标准
+
 ## 开发
 
 ### 项目结构

package/README_EN.md

@@ -17,6 +17,7 @@ An ESLint plugin based on personal naming conventions, supporting naming convent
 - ✅ **Word Length Limit** - Each word limited to maximum 8 characters
 - ✅ **Forbidden Words** - Avoids redundant words like Manager, Handler, etc.
 - ✅ **JSDoc Support** - Integrated JSDoc documentation requirements
+- ✅ **Naming Recommendations** - Recommends shorter alternative names while preserving semantic meaning
 
 ## Installation
 
@@ -268,8 +269,98 @@ const customConfig = {
 };
 
 const detector = new NamingDetector(customConfig);
+
+## Naming Recommendation Feature
+
+The plugin includes an intelligent naming recommendation system that suggests shorter alternative names while preserving semantic meaning.
+
+### Principle
+
+The core principle is **"shorten names without changing semantics"**. The recommendation system:
+- Recommends shorter words that maintain the same meaning
+- Avoids conceptual changes that would alter functionality
+- Ensures recommended words are always shorter than the original
+- Preserves programming-specific terminology and conceptual differences
+
+### Configuration
+
+Enable the recommendation feature in your ESLint configuration:
+
+```javascript
+// eslint.config.js
+const namingConventionPlugin = require("mm-eslint-plugin");
+
+module.exports = [
+  {
+    files: ["**/*.js"],
+    plugins: {
+      "naming-convention": namingConventionPlugin,
+    },
+    rules: {
+      "naming-convention/class-name": "error",
+      "naming-convention/function-name": ["error", { recommen: true }], // Enable recommendations
+      // ... other rules
+    },
+  },
+];
+```
+
+### Available Recommendations
+
+The plugin provides recommendations for common programming operations:
+
+| Original Word | Recommended Word | Description |
+|---------------|------------------|-------------|
+| `calculate` | `calc` | Mathematical operations |
+| `generate` | `gen` | Data generation |
+| `initialize` | `init` | Initialization operations |
+| `execute` | `exec` | Command execution |
+| `process` | `run` | Data processing |
+| `retrieve` | `load` | Data loading |
+| `persist` | `save` | Data storage |
+| `compare` | `cmp` | Comparison operations |
+| `duplicate` | `copy` | Data copying |
+| `transfer` | `move` | Data movement |
+| `convert` | `to` | Type conversion |
+| `verify` | `check` | Validation checks |
+| `construct` | `create` | Object creation |
+| `handle` | `run` | Event handling |
+
+### Examples
+
+```javascript
+// ❌ Original (longer names)
+function calculateTotal() {}
+function generateUserData() {}
+function initializeSystem() {}
+function executeCommand() {}
+function processData() {}
+
+// ✅ Recommended (shorter names)
+function calcTotal() {}
+function genUserData() {}
+function initSystem() {}
+function execCommand() {}
+function runData() {}
+```
+
+### Error Messages with Recommendations
+
+When the recommendation feature is enabled, ESLint will suggest alternative names:
+
+```bash
+# ESLint output example
+function calculateTotal() {}
+# ^ Recommend using 'calc' instead of 'calculate' for shorter naming
 ```
 
+### Benefits
+
+1. **Improved Readability**: Shorter names are easier to read and understand
+2. **Consistent Codebase**: Standardized naming across the project
+3. **Semantic Preservation**: Meaning is maintained while reducing verbosity
+4. **Programming Best Practices**: Follows industry standards for concise naming
+
 ## Development
 
 ### Project Structure

package/index.js

@@ -5,19 +5,239 @@
  */
 class Detector {
   static config = {
-    forbidden_words: [
-      "manager",
-      "handler",
-      "processor",
-      "controller",
-      "Management",
-      "Handler",
-      "Processor",
-      "Controller",
-      "LoggerManager",
-      "AppState",
-      "UserHandler",
-    ],
+    // 推荐词功能开关
+    recommen: true,
+    // 推荐词，当命名时较长时推荐使用的词
+    recommen_words: {
+      // 函数推荐词
+      function: {
+        // === 动词类 ===
+        // 增加
+        add: {
+          words: ["push", "insert"]
+        },
+        // 删除
+        del: {
+          words: ["remove", "delete"]
+        },
+        // 查询
+        get: {
+          words: ["query"]
+        },
+        // 修改
+        set: {
+          words: ["setting"]
+        },
+        // 转换
+        to: {
+          words: ["convert", "transform"]
+        },
+        // 检查
+        check: {
+          words: ["verify", "validate", "confirm"]
+        },
+        // 创建
+        create: {
+          words: ["construct"]
+        },
+        // 生成
+        gen: {
+          words: ["generate"]
+        },
+        // 初始化
+        init: {
+          words: ["initialize"]
+        },
+        // 处理
+        run: {
+          words: ["process", "handle"]
+        },
+        // 执行
+        exec: {
+          words: ["execute"]
+        },
+        // 计算
+        calc: {
+          words: ["calculate", "compute"]
+        },
+        // 加载
+        load: {
+          words: ["fetch", "retrieve"]
+        },
+        // 保存
+        save: {
+          words: ["store", "persist"]
+        },
+        // 比较
+        cmp: {
+          words: ["compare", "diff"]
+        },
+        // 排序
+        sort: {
+          words: ["order", "arrange"]
+        },
+        // 查找
+        find: {
+          words: ["search", "locate"]
+        },
+        // 删除
+        del: {
+          words: ["remove", "delete"]
+        },
+        // 解析
+        parse: {
+          words: ["analyze"]
+        },
+        // 复制
+        copy: {
+          words: ["duplicate", "clone"]
+        },
+        // 移动
+        move: {
+          words: ["transfer", "relocate"]
+        },
+        // 压缩
+        zip: {
+          words: ["compress"]
+        },
+        // 解压
+        unzip: {
+          words: ["decompress"]
+        },
+        // 反转
+        flip: {
+          words: ["reverse"]
+        },
+        // === 名词类 ===
+        // 函数
+        Func: {
+          words: ["Function"]
+        },
+        // 值
+        Val: {
+          words: ["Value"]
+        },
+        // 数组
+        Arr: {
+          words: ["Array"]
+        },
+        // 对象
+        Obj: {
+          words: ["Object"]
+        },
+        // 数值
+        Num: {
+          words: ["Number"]
+        },
+        // 字符串
+        Str: {
+          words: ["String"]
+        },
+        // 字典
+        Dict: {
+          words: ["Dictionary"]
+        }
+      },
+      variable: {
+        // 连接器
+        conn: {
+          words: ["connector"]
+        },
+        // 函数
+        func: {
+          words: ["function"]
+        },
+        // 值
+        val: {
+          words: ["value"]
+        },
+        // 枚举
+        enum: {
+          words: ["enumeration"]
+        },
+        // 数组
+        arr: {
+          words: ["array"]
+        },
+        // 对象
+        obj: {
+          words: ["object"]
+        },
+        // 数值
+        num: {
+          words: ["number"]
+        },
+        // 字符串
+        str: {
+          words: ["string"]
+        },
+        bool: {
+          words: ["boolean"]
+        },
+        // 字典
+        dict: {
+          words: ["dictionary"]
+        },
+        // 模块
+        mod: {
+          words: ["module"]
+        }
+      }
+    },
+    // 废话词
+    forbidden_words: {
+      // 类废话词：禁止在类名中使用的冗余拼接词汇（统一小写）
+      // 这些词汇在类名中属于过度设计或冗余描述，即使在某些场景下合理，但作为拼接命名仍然是冗余的
+      class: [
+        "manager", "handler", "processor", "controller", "service", "provider",
+        "factory", "builder", "adapter", "decorator", "proxy", "facade",
+        "mediator", "observer", "strategy", "command", "visitor",
+        "iterator", "template", "flyweight", "memento", "interpreter",
+        "model", "view", "route", "router", "component", "widget", "panel",
+        "dialog", "window", "form", "field", "property", "entity"
+        // 例如：UserModel → User (直接使用User)，UserController → User (直接使用User)
+      ],
+
+      // 函数废话词：禁止在函数名中使用的冗余拼接词汇（统一小写）
+      // 基于动词+名词组合分析：如果动词已经表达了动作，名词只是数据描述，则名词是废话词
+      // 有意义的词通常是拼接get、set、to后能有意义、直接表达的名词，如getUser、toJSON等
+      function: [
+        // 无意义的数据描述词汇（动词已经表达了动作，这些名词是冗余的）
+        "data", "result", "output", "input", "param", "params", "parameter", "parameters",
+        "value", "values", "item", "items",
+        // 通用处理词汇（动词已经表达了处理，这些名词是冗余的）
+        "process", "handler", "processor", "manager", "controller", "service", "provider",
+        "factory", "builder", "adapter", "decorator", "proxy", "facade", "mediator",
+        "observer", "strategy", "command", "visitor", "iterator", "template",
+        "flyweight", "memento", "interpreter",
+        // 临时缓存词汇（动词已经表达了操作，这些名词是冗余的）
+        "temp", "tmp", "temporary", "cached", "buffered",
+        // 计数索引词汇（动词已经表达了计数索引，这些名词是冗余的）
+        "idx", "counter",
+        // 例如：getData → get（data是冗余），toResult → to（result是冗余）
+        // processData → process（data是冗余），handleRequest → handle（request是冗余）
+      ],
+
+      // 变量废话词：禁止在变量名中使用的冗余拼接词汇（统一小写）
+      // 这些词汇在变量名中属于"不用说也知道"的过度描述
+      variable: [
+        // 数据类型词：变量本身就有类型，不需要重复说明
+        "object", "array", "map", "set", "collection", "container", "instance",
+        // 通用数据词：变量本身就是数据/值，不需要重复说明
+        "value", "data", "item", "items", "element", "elements", "entry", "entries",
+        // 临时状态词：临时变量不需要说明是临时的
+        "temp", "tmp", "temporary", "cache", "cached", "buffer", "buffered",
+        // 输入输出词：变量本身就有用途，不需要重复说明
+        "input", "output", "result", "source", "target", "destination",
+        // 计数索引词：变量本身就有计数/索引功能，不需要重复说明
+        "count", "index", "idx", "counter", "length", "size", "total", "sum",
+        // 引用指针词：变量本身就是引用/指针，不需要重复说明
+        "pointer", "reference", "ref", "handle", "handler",
+        // 通用描述词：变量本身就是实体，不需要重复说明
+        "entity", "record", "row", "column", "cell", "field", "property", "attr", "attribute"
+        // 例如：user_list → users（list是冗余），temp_value → temp（value是冗余）
+      ]
+    },
     regex: {
       PascalCase: /^[A-Z][a-zA-Z]*$/, // 大驼峰：大写字母开头，只包含字母。主要用于类名
       camelCase: /^[a-z][a-zA-Z]*$/, // 小驼峰：小写字母开头，只包含字母。主要用于方法名、函数名
@@ -159,8 +379,10 @@ class Detector {
     // 合并默认配置和传入配置
     const merged_cfg = { ...Detector.config };
     if (config && typeof config === "object") {
+      // 先合并顶层配置
       Object.keys(config).forEach((key) => {
-        if (merged_cfg[key]) {
+        if (merged_cfg[key] && typeof merged_cfg[key] === "object" && !Array.isArray(merged_cfg[key])) {
+          // 如果是对象配置（如规则配置），则深度合并
           merged_cfg[key] = { ...merged_cfg[key], ...config[key] };
 
           // 处理字符串形式的正则表达式
@@ -183,6 +405,9 @@ class Detector {
               merged_cfg[key].regex = null;
             }
           }
+        } else {
+          // 如果是顶层字段（如recommen），直接覆盖
+          merged_cfg[key] = config[key];
         }
       });
     }
@@ -250,17 +475,20 @@ Detector.prototype._checkName = function (rule_type, name) {
 
   const errors = [];
   const warnings = [];
+  const recommendations = [];
 
   this._checkNameLength(name, config, errors);
   this._checkNameFormat(name, rule_type, config, errors);
   this._checkBadWords(name, config, errors);
   this._checkSingleWord(name, rule_type, config, warnings);
   this._checkWordLength(name, rule_type, config, errors);
+  this._checkRecommen(name, rule_type, config, recommendations);
 
   return {
     valid: errors.length === 0,
     errors: errors,
     warnings: warnings,
+    recommendations: recommendations,
   };
 };
 
@@ -317,7 +545,16 @@ Detector.prototype._checkNameFormat = function (
  * @private
  */
 Detector.prototype._checkBadWords = function (name, config, errors) {
-  if (this._hasBadWord(name)) {
+  // 根据配置类型确定代码实体类型
+  let type = 'variable'; // 默认变量类型
+
+  if (config.name.includes('类名')) {
+    type = 'class';
+  } else if (config.name.includes('函数名') || config.name.includes('方法名')) {
+    type = 'function';
+  }
+
+  if (this._hasBadWord(name, type)) {
     errors.push(`${config.name}包含禁止的废话词`);
   }
 };
@@ -1173,23 +1410,145 @@ Detector.prototype._isConstPat = function (prop_name, value) {
 };
 
 /**
- * 检查是否包含禁止的废话词
+ * 检查是否包含禁止的废话词（拼接命名检测）
  * @param {string} name - 名称
+ * @param {string} type - 代码实体类型（class/function/variable）
  * @returns {boolean} 是否包含禁止词
  * @private
  */
-Detector.prototype._hasBadWord = function (name) {
-  if (!name) {
+Detector.prototype._hasBadWord = function (name, type) {
+  if (!name || !type) {
     return false;
   }
 
-  const forbidden_words = this.config.forbidden_words || [];
+  const forbidden_words = this.config.forbidden_words[type] || [];
+  const nameLower = name.toLowerCase();
+
+  // 检测拼接命名：名称由多个单词组成，且包含禁止词
+  // 例如：UserManager（包含manager）、DataHandler（包含handler）
+  // 但允许单个单词：Manager、Handler等
+
+  // 如果名称是单个单词，不进行废话词检测
+  if (!this._isCompoundName(name)) {
+    return false;
+  }
 
   return forbidden_words.some((word) =>
-    name.toLowerCase().includes(word.toLowerCase()),
+    nameLower.includes(word.toLowerCase()),
   );
 };
 
+/**
+ * 检查是否为拼接命名（由多个单词组成）
+ * @param {string} name - 名称
+ * @returns {boolean} 是否为拼接命名
+ * @private
+ */
+Detector.prototype._isCompoundName = function (name) {
+  if (!name) {
+    return false;
+  }
+
+  // 检测大驼峰命名（PascalCase）：每个单词首字母大写
+  if (/^[A-Z][a-z]+([A-Z][a-z]+)+$/.test(name)) {
+    return true;
+  }
+
+  // 检测小驼峰命名（camelCase）：第一个单词小写，后续单词首字母大写
+  if (/^[a-z]+([A-Z][a-z]+)+$/.test(name)) {
+    return true;
+  }
+
+  // 检测蛇形命名（snake_case）：单词间以下划线分隔
+  if (/^[a-z]+(_[a-z]+)+$/.test(name)) {
+    return true;
+  }
+
+  // 检测横杠命名（kebab-case）：单词间以短横线分隔
+  if (/^[a-z]+(-[a-z]+)+$/.test(name)) {
+    return true;
+  }
+
+  return false;
+};
+
+/**
+ * 检查推荐词并生成推荐建议
+ * @param {string} name - 名称
+ * @param {string} rule_type - 规则类型
+ * @param {Object} config - 配置
+ * @param {Array} recommendations - 推荐建议数组
+ * @private
+ */
+Detector.prototype._checkRecommen = function (name, rule_type, config, recommendations) {
+  // 只对函数和方法名进行推荐词检测
+  if (rule_type !== "function-name" && rule_type !== "method-name") {
+    return;
+  }
+
+  const recommen_words = this.config.recommen_words.function;
+  
+  // 拆分命名中的单词
+  const words = this._splitWords(name, rule_type);
+
+  // 检查每个推荐词类别
+  Object.keys(recommen_words).forEach((category) => {
+    const category_config = recommen_words[category];
+    const category_words = category_config.words || [];
+
+    // 检查拆分后的单词是否包含推荐词类别对应的推荐词
+    let has_target_word = false;
+    words.forEach((word) => {
+      if (category_words.includes(word)) {
+        // 如果单词是目标词（如remove、delete），则生成建议
+        has_target_word = true;
+      }
+    });
+
+    // 如果包含目标词，则生成建议
+    if (has_target_word) {
+      // 检查是否需要生成推荐
+      let should_recommend = false;
+      
+      if (this.config.recommen) {
+        // recommen为true：所有符合条件的命名都应该推荐
+        should_recommend = true;
+      } else {
+        // recommen为false：只有当命名中出现单个词汇长度超过指定字符或命名总长度超过限制时才推荐
+        const has_long_word = words.some(word => word.length > (config.single_word_len || 8));
+        const has_long_name = name.length > config.max;
+        
+        should_recommend = has_long_word || has_long_name;
+      }
+
+      if (should_recommend) {
+        // 生成推荐建议：将目标词替换为推荐类别词
+        const suggestions = category_words.map((word) => {
+          // 智能替换：保持原始大小写格式
+          const regex = new RegExp(word, 'gi');
+          return name.replace(regex, (match) => {
+            // 保持原始大小写格式
+            if (match === match.toUpperCase()) {
+              return category.toUpperCase();
+            } else if (match[0] === match[0].toUpperCase()) {
+              return category[0].toUpperCase() + category.slice(1);
+            } else {
+              return category;
+            }
+          });
+        });
+
+        recommendations.push({
+          original: name,
+          category: category,
+          suggestions: suggestions,
+          message: `检测到"${category_words.join('、')}"，推荐使用: ${suggestions.join(', ')}`
+        });
+      }
+    }
+  });
+};
+
 /**
  * 检测名称是否符合规范
  * @param {string} name - 名称
@@ -1256,7 +1615,7 @@ const class_name_rule = {
     docs: {
       description: "类名必须使用大驼峰命名法（PascalCase）且优先使用单个单词",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1304,7 +1663,7 @@ const function_name_rule = {
     docs: {
       description: "函数名必须使用小驼峰命名法（camelCase）且优先使用单个单词",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1371,7 +1730,7 @@ const method_name_rule = {
     docs: {
       description: "方法名必须使用小驼峰命名法（camelCase）且优先使用单个单词",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1436,7 +1795,7 @@ const variable_name_rule = {
     docs: {
       description: "变量名必须使用小写蛇形命名法（snake_case）",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1460,7 +1819,8 @@ const variable_name_rule = {
     function isRealConstant(node) {
       // 真正的常量特征：
       // 1. 在模块顶层作用域（不在函数或块内）
-      // 2. 名称包含大写字母（表示意图作为常量）
+      // 2. 名称符合常量命名模式（全大写或大写蛇形）
+      // 3. 不是模块导入（避免将require导入识别为常量）
 
       // 检查是否在模块顶层
       let scope_node = node;
@@ -1476,9 +1836,23 @@ const variable_name_rule = {
         }
       }
 
-      // 检查名称是否包含大写字母（表示意图作为常量）
+      // 检查是否是模块导入（避免将require导入识别为常量）
+      if (node.init &&
+        (node.init.type === "CallExpression" &&
+          node.init.callee &&
+          node.init.callee.name === "require")) {
+        return false; // 这是模块导入，不是真正的常量
+      }
+
+      // 检查名称是否符合常量命名模式
       const name = node.id.name;
-      return /[A-Z]/.test(name);
+
+      // 常量命名模式：全大写或大写蛇形
+      const is_uppercase = /^[A-Z][A-Z0-9]*$/.test(name); // 全大写：PORT, DEBUG
+      const is_upper_snake = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/.test(name); // 大写蛇形：API_BASE_URL
+
+      // 只有符合常量命名模式的才被认为是真正的常量
+      return is_uppercase || is_upper_snake;
     }
 
     return {
@@ -1489,6 +1863,89 @@ const variable_name_rule = {
             return; // 这是真正的常量，由常量规则处理
           }
 
+          // 检查是否是函数声明（由函数名规则处理，这里跳过）
+          if (node.init &&
+            (node.init.type === "FunctionExpression" ||
+              node.init.type === "ArrowFunctionExpression")) {
+            // 这是函数声明，由函数名规则处理，这里跳过避免重复检测
+            return;
+          }
+
+          // 检查是否是类实例
+          if (node.init &&
+            node.init.type === "NewExpression" &&
+            node.init.callee &&
+            node.init.callee.type === "Identifier" &&
+            /^[A-Z][a-zA-Z]*$/.test(node.init.callee.name)) {
+            // 这是类实例，应该由变量名规则处理（类实例是变量，不是类）
+            const class_instance_name = node.id.name;
+            const detector = new Detector({ "variable-name": options });
+            const result = detector.checkName(class_instance_name, "variable-name");
+
+            if (!result.valid) {
+              result.errors.forEach((error) => {
+                context.report({
+                  node: node.id,
+                  message: `类实例名"${class_instance_name}"不符合规范: ${error}`,
+                });
+              });
+            }
+            return;
+          }
+
+          // 检查是否是模块导入
+          if (node.init &&
+            node.init.type === "CallExpression" &&
+            node.init.callee &&
+            node.init.callee.name === "require") {
+            // 这是模块导入，应用模块导入命名规则
+            const module_name = node.id.name;
+
+            // 智能判断模块导入的命名风格
+            if (/^[A-Z][a-zA-Z]*$/.test(module_name)) {
+              // 类/构造函数导入：Koa, Express - 应该使用PascalCase
+              const detector = new Detector({ "class-name": options });
+              const result = detector.checkName(module_name, "class-name");
+
+              if (!result.valid) {
+                result.errors.forEach((error) => {
+                  context.report({
+                    node: node.id,
+                    message: `模块导入名"${module_name}"不符合规范: ${error}`,
+                  });
+                });
+              }
+            } else if (/^[a-z][a-zA-Z]*$/.test(module_name)) {
+              // 默认导出导入：express, config - 应该使用camelCase
+              const detector = new Detector({ "function-name": options });
+              const result = detector.checkName(module_name, "function-name");
+
+              if (!result.valid) {
+                result.errors.forEach((error) => {
+                  context.report({
+                    node: node.id,
+                    message: `模块导入名"${module_name}"不符合规范: ${error}`,
+                  });
+                });
+              }
+            } else {
+              // 其他情况（如path, fs） - 使用变量名规则
+              const detector = new Detector({ "variable-name": options });
+              const result = detector.checkName(module_name, "variable-name");
+
+              if (!result.valid) {
+                result.errors.forEach((error) => {
+                  context.report({
+                    node: node.id,
+                    message: `模块导入名"${module_name}"不符合规范: ${error}`,
+                  });
+                });
+              }
+            }
+            return;
+          }
+
+          // 真正的变量声明
           const variable_name = node.id.name;
           const detector = new Detector({ "variable-name": options });
           const result = detector.checkName(variable_name, "variable-name");
@@ -1516,7 +1973,7 @@ const constant_name_rule = {
     docs: {
       description: "常量名必须使用大写蛇形命名法（UPPER_SNAKE_CASE）",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1540,8 +1997,8 @@ const constant_name_rule = {
     function isRealConstant(node) {
       // 真正的常量特征：
       // 1. 在模块顶层作用域（不在函数或块内）
-      // 2. 名称包含大写字母（表示意图作为常量）
-      // 3. 或者名称是常见的常量模式（如全大写）
+      // 2. 名称符合常量命名模式（全大写或大写蛇形）
+      // 3. 不是模块导入（避免将require导入识别为常量）
 
       // 检查是否在模块顶层
       let scope_node = node;
@@ -1557,9 +2014,23 @@ const constant_name_rule = {
         }
       }
 
-      // 检查名称是否包含大写字母（表示意图作为常量）
+      // 检查是否是模块导入（避免将require导入识别为常量）
+      if (node.init &&
+        (node.init.type === "CallExpression" &&
+          node.init.callee &&
+          node.init.callee.name === "require")) {
+        return false; // 这是模块导入，不是真正的常量
+      }
+
+      // 检查名称是否符合常量命名模式
       const name = node.id.name;
-      return /[A-Z]/.test(name);
+
+      // 常量命名模式：全大写或大写蛇形
+      const is_uppercase = /^[A-Z][A-Z0-9]*$/.test(name); // 全大写：PORT, DEBUG
+      const is_upper_snake = /^[A-Z][A-Z0-9_]*(_[A-Z0-9]+)*$/.test(name); // 大写蛇形：API_BASE_URL
+
+      // 只有符合常量命名模式的才被认为是真正的常量
+      return is_uppercase || is_upper_snake;
     }
 
     return {
@@ -1595,7 +2066,7 @@ const param_name_rule = {
     docs: {
       description: "入参名必须使用小写蛇形命名法（snake_case）",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1664,7 +2135,7 @@ const prop_name_rule = {
     docs: {
       description: "属性名必须使用小写蛇形命名法（snake_case）",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1726,7 +2197,7 @@ const private_method_rule = {
     docs: {
       description: "私有方法必须以单下划线开头，后跟小驼峰命名或小写单词",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1779,7 +2250,7 @@ const private_variable_rule = {
     docs: {
       description: "私有变量必须以单下划线开头，后跟小写蛇形命名或小写单词",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1832,7 +2303,7 @@ const instance_property_rule = {
     docs: {
       description: "实例属性赋值必须符合命名规范",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1888,7 +2359,7 @@ const prototype_method_rule = {
     docs: {
       description: "原型方法名必须使用小驼峰命名法（camelCase）且优先使用单个单词",
       category: "Stylistic Issues",
-      recommended: true,
+      recommen: true,
     },
     schema: [
       {
@@ -1917,15 +2388,10 @@ const prototype_method_rule = {
           node.left.object.property.type === "Identifier" &&
           node.left.object.property.name === "prototype" &&
           node.left.property.type === "Identifier" &&
-          (node.right.type === "FunctionExpression" || 
-           node.right.type === "ArrowFunctionExpression")
+          (node.right.type === "FunctionExpression" ||
+            node.right.type === "ArrowFunctionExpression")
         ) {
           const method_name = node.left.property.name;
-          
-          // 跳过私有方法的检测（私有方法由private-naming规则处理）
-          if (method_name.startsWith("_")) {
-            return;
-          }
 
           // 跳过JavaScript内置特殊方法名
           const builtin_methods = [
@@ -1938,8 +2404,10 @@ const prototype_method_rule = {
             return;
           }
 
-          const detector = new Detector({ "method-name": options });
-          const result = detector.checkName(method_name, "method-name");
+          // 根据方法名是否以下划线开头，选择不同的检测规则
+          const rule_name = method_name.startsWith("_") ? "private-method-naming" : "method-name";
+          const detector = new Detector({ [rule_name]: options });
+          const result = detector.checkName(method_name, rule_name);
 
           if (!result.valid) {
             result.errors.forEach((error) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mm_eslint",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "ESLint plugin for naming conventions - PascalCase, camelCase, snake_case, and UPPER_SNAKE_CASE naming rules",
   "main": "index.js",
   "keywords": [
@@ -32,7 +32,7 @@
     "eslint": ">=8.0.0"
   },
   "scripts": {
-    "test": "node test.js",
+    "test": "node tests/test_new_recommen_words.js",
     "lint": "npx eslint . --config eslint.config.js"
   },
   "files": [