crabatool 1.0.431 → 1.0.432

package/apis/data.js

@@ -10,6 +10,7 @@ class data {
   constructor() {
     this.dslMap = {};
     this.pagesDataChanged = {};
+    this.pageDataValitions = {};
     this.dsl = {};
     this.dataRefs = [];
   }
@@ -48,6 +49,7 @@ class data {
     });
 
     this.pagesDataChanged = dslData.pagesDataChanged ? dslData.pagesDataChanged : {}
+    this.pageDataValitions = dslData.pageDataValitions ? dslData.pageDataValitions : {}
   }
 
   _getDb(req) {
@@ -161,7 +163,7 @@ class data {
     }
   }
 
-  async reverseData(req, pageName, body) {
+  async reverseData(req, pageName, body, newData) {
     var oldEntity = await this._getDb(req).get(body.name, body.data.id);
     if (!oldEntity) {
       crabatool.utils.end(res, {
@@ -170,6 +172,7 @@ class data {
       });
       return;
     }
+    await this.pageSaveToDataValidation(pageName, oldEntity, newData);
     //退回联动老数据
     var rt = await this.pageSaveToDataLinkage(req, body.name, pageName, oldEntity, null, true);
     return {
@@ -186,7 +189,7 @@ class data {
     var rtData = JSON.parse(JSON.stringify(body.data));
     var name = body.name;
     if (body.data.id) {
-      var oldData = await this.reverseData(req, pageName, body);
+      var oldData = await this.reverseData(req, pageName, body, body.data);
       if (!oldData) {
         return;
       }
@@ -197,6 +200,7 @@ class data {
       await db.update(name, body.data.id, body.data);
       newData = body.data;
     } else {
+      await this.pageSaveToDataValidation(pageName, null, rtData);
       //提前制定ID
       body.data.id = cuid.newCuidString()
       await this.buildDataPrimaryAndForeignKey(name, body.data);
@@ -271,6 +275,49 @@ class data {
     return this.findLayerData(data[items[0]], items.slice(1), layer)
   }
 
+  // 保存页面数据验证
+  async pageSaveToDataValidation(pageName, oldData, newData) { 
+    if(!this.pageDataValitions || !this.pageDataValitions[pageName]){
+      return;
+    }
+    var validation = this.pageDataValitions[pageName];
+    // 数据存在验证只需要验证新数据(必填验证/关联数据存在验证)
+    var exist = validation.exist;
+    await this.validationExist(exist, pageName, newData);
+    // 数据对比验证需要把新老数据合并后验证，合并需要能读取到合并条件
+  }
+
+  async validationExist(exist, pageName, newData){
+    // var _this = this;
+    // var rt = new Set();
+    // for(var i = 0; exist && i < exist.length; i++){
+    //   var item = exist[i];
+    //   var cs = _this.findFormateItem(item.filter.refField)
+    //   var rtData = _this.findItemMapData(pageName, crabatool.stringUtils.getFullPinyinCode(item.ref), newData, cs);
+    //   var levels = item.filter.refField.split('.');
+    //   if(!rtData){
+    //     rt.add(item.info);
+    //     continue;
+    //   }
+    //   if(levels.length == 1){
+    //     if(!rtData[levels[0]]){
+    //       rt.add(item.info);
+    //       continue;
+    //     }
+    //   } else {
+    //     var array = rtData[levels[0]];
+    //     for(var m = 0 ; m < array.length; m++){
+    //       var a = array[m];
+    //       if(!a[levels[1]]){//有一条存在空，就提示
+    //         rt.add(item.info);
+    //         continue;
+    //       }
+    //     }
+    //   }
+    // }
+    // console.log(rt);
+  }
+
   //reverseNumber：true，按规则撤销原始数据对外表的变动
   async pageSaveToDataLinkage(req, name, pageName, data, oldData, reverseNumber) {
     //页面数据保存带来的多数据联动处理

package/examples/simple-file-watch.js

@@ -0,0 +1,193 @@
+#!/usr/bin/env node
+
+/*
+  简化的打开文件监听示例 + 代码检测
+  监听文件变化并自动执行代码检测
+*/
+
+var path = require('path');
+var fs = require('fs');
+var openFileWatcher = require('../tool/openFileWatcher.js');
+
+console.log('📁 文件监听 + 代码检测示例');
+console.log('==========================\n');
+
+// 示例1: 基本监听 + 代码检测
+function basicWatch() {
+  console.log('🔍 启动文件监听 + 代码检测...');
+  
+  const watcher = openFileWatcher.createWatcher({
+    watchExtensions: ['.js'],
+    debounceDelay: 300,
+    verbose: false
+  });
+  
+  // 启动监听
+  watcher.start('./test');
+  
+  // 手动添加一些文件到监听列表
+  // if (fs.existsSync('./test/test.js')) {
+  //   watcher.addOpenFile('./test/test.js');
+  // }
+  // if (fs.existsSync('./test/craba.js')) {
+  //   watcher.addOpenFile('./test/craba.js');
+  // }
+  
+  console.log('✅ 监听已启动');
+  console.log('📂 监听目录: ./test');
+  console.log('📄 监听文件:', watcher.getOpenFiles());
+  console.log('');
+  console.log('💡 现在可以修改 test/ 目录下的 .js 文件来观察代码检测效果');
+  console.log('🔍 JavaScript 文件变化时会自动执行:');
+  console.log('   - ESLint 语法检查');
+  console.log('   - 文件编码检查');
+  console.log('   - 文件大小检查');
+  console.log('   - ES6+ 兼容性检查');
+  console.log('⏹️  按 Ctrl+C 停止监听');
+  
+  // 优雅退出处理
+  process.on('SIGINT', () => {
+    console.log('\n🛑 正在停止监听...');
+    watcher.stop();
+    console.log('✅ 监听已停止');
+    process.exit(0);
+  });
+}
+
+// 示例2: 监听当前目录的重要文件
+function watchCurrentDir() {
+  console.log('🔍 监听当前目录的重要文件...');
+  
+  const watcher = openFileWatcher.createWatcher({
+    watchExtensions: ['.js'],
+    ignored: [
+      /node_modules/,
+      /\.git/,
+      /examples/,
+      /docs/
+    ],
+    debounceDelay: 500,
+    verbose: false
+  });
+  
+  watcher.start('./');
+  
+  // 添加一些重要文件
+  const importantFiles = [
+    './index.js',
+    './run.js'
+  ];
+  
+  importantFiles.forEach(file => {
+    if (fs.existsSync(file)) {
+      watcher.addOpenFile(file);
+    }
+  });
+  
+  console.log('✅ 当前目录监听已启动');
+  console.log('📄 重要文件:', watcher.getOpenFiles());
+  console.log('');
+  console.log('💡 修改 index.js 或 run.js 来观察代码检测');
+  console.log('⏹️  按 Ctrl+C 停止监听');
+  
+  process.on('SIGINT', () => {
+    console.log('\n🛑 正在停止监听...');
+    watcher.stop();
+    console.log('✅ 监听已停止');
+    process.exit(0);
+  });
+}
+
+// 示例3: 显示使用说明
+function showUsage() {
+  console.log('📖 文件监听 + 代码检测使用说明');
+  console.log('==============================\n');
+  
+  console.log('🎯 功能特点:');
+  console.log('- 监听指定的 JavaScript 文件变化');
+  console.log('- 文件变化时自动执行代码检测');
+  console.log('- 集成 ESLint 语法检查');
+  console.log('- 检查文件编码和大小');
+  console.log('- 检查 ES6+ 兼容性问题');
+  console.log('- 详细的检测结果输出');
+  console.log('');
+  
+  console.log('🚀 在 crabaTool 中使用:');
+  console.log('1. 启动开发服务器:');
+  console.log('   crabatool -run -webPath ./your-project -refresh true');
+  console.log('');
+  console.log('2. 服务器会自动启动文件监听');
+  console.log('3. 修改 JavaScript 文件时会自动执行代码检测');
+  console.log('4. 在服务器控制台看到详细的检测结果');
+  console.log('');
+  
+  console.log('🔧 检测内容:');
+  console.log('- ESLint 语法检查 (错误、警告、未定义变量等)');
+  console.log('- 文件编码检查 (建议使用 UTF-8)');
+  console.log('- 文件大小检查 (超过 300KB 会提示)');
+  console.log('- ES6+ 语法检查 (let, const, 箭头函数等)');
+  console.log('- 兼容性问题检测 (IE 浏览器兼容性)');
+  console.log('');
+  
+  console.log('📝 检测结果示例:');
+  console.log('');
+  console.log('[13:41:45] /Users/dev/project/src/demo-check.js (change) - 1.01 KB');
+  console.log('开始检测 JavaScript 文件...');
+  console.log('   编码: UTF-8 | 大小: 1.01KB | 语法: 2错误,2未定义 | 兼容性: 发现4个ES6+语法');
+  console.log('   严重问题详情:');
+  console.log('      第33行: Do not use let.');
+  console.log('      第34行: Do not use const.');
+  console.log('   兼容性问题: let, const');
+  console.log('');
+  console.log('正常文件示例:');
+  console.log('[13:42:10] /Users/dev/project/src/utils.js (change) - 2.3 KB');
+  console.log('开始检测 JavaScript 文件...');
+  console.log('   编码: UTF-8 | 大小: 2.30KB | 语法: 无问题 | 兼容性: 无ES6+语法');
+  console.log('');
+  console.log('注意: 实际运行时会显示彩色输出');
+  console.log('- 绿色: 检查通过');
+  console.log('- 黄色: 警告问题');
+  console.log('- 红色: 严重问题');
+  console.log('');
+  
+  console.log('💡 提示:');
+  console.log('- 红色 ❌ 表示必须修复的问题');
+  console.log('- 黄色 ⚠️ 表示建议修复的问题');
+  console.log('- 蓝色 💡 表示可选修复的问题');
+  console.log('- 绿色 ✅ 表示检查通过');
+}
+
+// 主函数
+function main() {
+  const args = process.argv.slice(2);
+  
+  switch (args[0]) {
+    case 'basic':
+      basicWatch();
+      break;
+    case 'current':
+      watchCurrentDir();
+      break;
+    case 'usage':
+      showUsage();
+      break;
+    default:
+      console.log('🚀 可用示例:');
+      console.log('');
+      console.log('node examples/simple-file-watch.js basic   - 基本文件监听 + 代码检测');
+      console.log('node examples/simple-file-watch.js current - 监听当前目录重要文件');
+      console.log('node examples/simple-file-watch.js usage   - 使用说明');
+      console.log('');
+      console.log('💡 提示: 运行示例后，修改相应的 JavaScript 文件来观察代码检测效果');
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  basicWatch,
+  watchCurrentDir,
+  showUsage
+};

package/lib/config.js

@@ -7,6 +7,8 @@ class Config {
     //this.reportHost = "http://crabadoc.ca.com"; // 用于接收检测报告的服务器，可配置的。由于产品没有提供服务，目前统一放到平台的文档服务器
     //this.reportHost = "http://127.0.0.1:9998";
     this.reportHost = 'http://172.17.0.201:9998';
+    this.baseWebHost = 'http://crabawork.ca.com';
+    this.baseWebHost ='http://127.0.0.1:9977';
 
     //this.SourceHost = "http://crabadoc.mygjp.com.cn";
     //this.SourceHost = "http://crabadoc.ca.com";

package/lib/utils.js

@@ -721,6 +721,12 @@ class Utils {
         if (!p1.endsWith('/') && !temp.startsWith('/')) s = '/';
         return p1 + s + temp;
     }
+    joinSep(temp) {
+        if (!temp) return temp;
+        var s = '';
+        if (!temp.startsWith('/')) s = '/';
+        return s + temp;
+    }
 
     downloadFile(uri, savePath, callback) {
         if (!uri || !savePath) throw new Error('uri或savePath不能为空');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crabatool",
-  "version": "1.0.431",
+  "version": "1.0.432",
   "description": "crabatool",
   "main": "index.js",
   "bin": {
@@ -21,7 +21,7 @@
     "upload": "node run.js -upload -version master -Debug true -host http://127.0.0.1:9998 -hidejspath true -targetPath F:\\CarpaNET_NEW",
     "crabaNgp": "node run.js -mergejs -hidejspath true -targetPath F:\\CarpaNET_NEW\\src\\Carpa.Web\\js\\crabaNgp -inNames initMs.js,businessControl.js -outName F:\\CarpaMS\\src\\js\\crabaNgp.js",
     "mergeJs2": "node run.js -mergejs -targetPath -inNames F:\\CarpaNET_NEW\\src\\Carpa.Web\\js\\craba.js,F:\\CarpaNET_NEW\\src\\Carpa.Web\\js\\controls.js -outName F:\\a.js -ignorecompress true",
-    "webPath": "node ./test/test.js -checkjs -webPath F:\\crabaevery\\www -modName crabaevery -Debug true",
+    "checkcrabaevery": "node ./test/test.js -checkjs -webPath F:\\crabaevery\\www -modName crabaevery -Debug false",
     "biconfont": "node ./test/test.js -iconfont -zipPath F:\\crabaevery\\www\\biconfont -fontPath F:\\crabaevery\\www\\skins\\bicon -prefix .bicon- -fontName biconfont",
     "aiconfont": "node ./test/test.js -iconfont -zipPath F:\\crabaevery\\www\\iconfont -fontPath F:\\CarpaNET_NEW\\src\\Carpa.Web\\skins -prefix .aicon- -fontName iconfont",
     "makeHash": "node run.js -makeHash -webPath ./test/ -modName craba  -files http://crabadoc.ca.com/js/utils/utils.js,F:/newcrabadoc/www/js/utils/utils.js,./test/test.js,./test/beefun.js,https://s5.vip.wpscdn.cn/web-libs/2t/js/userinfo-collect/1.0.3/vas2t-userinfo-collect.min.js?a=1 -outJson ./hash.json -hashName sha384",
@@ -31,39 +31,43 @@
     "gspxHash": "node run.js -gspxHash -webPath F:\\Beefun\\srcs\\Beefun",
     "runShell": "node run.js -run -webPath F:\\shell-gerrit\\web\\src\\main\\resources\\static\\shell\\ -port 10000 -modName shell",
     "runShellLocal": "node run.js -run -webPath F:\\shell-gerrit\\web\\src\\main\\resources\\static\\shell\\ -port 10000 -modName shell -localLogin true",
-    "runJxc": "node run.js -run -webPath F:\\jxc\\jxc-web\\src\\main\\resources\\static\\jxc\\ -port 10001 -modName jxc"
+    "runJxc": "node run.js -run -webPath F:\\jxc\\jxc-web\\src\\main\\resources\\static\\jxc\\ -port 10001 -modName jxc",
+    "open-file-watch": "node examples/simple-file-watch.js",
+    "open-file-test": "node examples/simple-file-watch.js basic",
+    "file-watch-usage": "node examples/simple-file-watch.js usage"
   },
   "author": "wssf",
   "dependencies": {
-    "body-parser": "^1.18.3",
-    "cookie-parser": "^1.4.5",
-    "cookie-signature": "^1.1.0",
     "axios": "^0.27.2",
+    "body-parser": "^1.18.3",
+    "chalk": "^4.1.2",
     "chokidar": "^3.5.3",
     "compressing": "^1.6.0",
     "compression": "^1.7.4",
+    "cookie-parser": "^1.4.5",
+    "cookie-signature": "^1.1.0",
     "crypto": "^1.0.1",
+    "crypto-js": "^3.1.9-1",
     "eslint": "^8.18.0",
     "eslint-plugin-native-ie": "0.1.2",
     "express": "^4.17.3",
+    "express-session": "^1.17.1",
     "htmlparser2": "^8.0.1",
     "http-proxy-middleware": "^2.0.6",
     "iconv-jschardet": "^2.0.26",
     "iconv-lite": "^0.5.2",
+    "js-pinyin": "^0.1.9",
+    "multiparty": "^4.2.2",
+    "mysql": "^2.18.1",
+    "node-xlsx": "0.21.0",
     "nodejs-websocket": "^1.7.2",
     "readline-sync": "^1.4.10",
     "request": "^2.88.2",
     "single-line-log": "^1.1.2",
     "sync-request": "^6.1.0",
     "uglify-js": "^3.15.1",
-    "xml-js": "^1.6.11",
     "uglifycss": "^0.0.29",
-    "mysql": "^2.18.1",
-    "crypto-js": "^3.1.9-1",
-    "js-pinyin": "^0.1.9",
-    "express-session": "^1.17.1",
-    "multiparty": "^4.2.2",
-    "node-xlsx": "0.21.0"
+    "xml-js": "^1.6.11"
   },
   "repository": {
     "type": "git",
@@ -73,4 +77,4 @@
     "crabatool"
   ],
   "license": "UNLICENSED"
-}
+}

package/tool/checkgspx.js

@@ -10,6 +10,8 @@ module.exports.getResults = function() {
     count: 0,
     tags: {},
     tagList: [],
+    customs1: {},
+    customs2: {},
     warnList: {},
     errorList: []
   };
@@ -63,6 +65,25 @@ function readGspxToJSON(fileName, data) {
           data.tags[name]++;
         }
 
+        // 统计customs
+        if (name == 'CustomControl') {
+          if (attrs.Src) {
+            // 统计当前页面引用了哪些CustomControl
+            var key1 = utils.joinSep(fileName.replaceAll('\\', '/'));
+            var key2 = utils.joinSep(attrs.Src.replace('~', '').replace('..',''));
+            if (!data.customs1[key1]) {
+              data.customs1[key1] = [];
+            }
+            data.customs1[key1].push(key2);
+
+            // 统计某个CustomControl被哪些页面引用
+            if (!data.customs2[key2]) {
+              data.customs2[key2] = [];
+            }
+            data.customs2[key2].push(key1);
+          }
+        }
+
         // 建议优化页面汇总
         if (warnTags.includes(name)) {
           if (name == 'CancelButton' || name == 'CloseButton') {

package/tool/checkjs.js

@@ -487,6 +487,7 @@ module.exports.start = async function() {
   var content = info.concat(detail).join('  \r\n');
   postReport(id, reportUrl, content, sonar);
   postReportData(reportData)
+  postBaseData(reportData, gspxData);
 
   // 推送到钉钉
   if (status != '无异常') { // 检查结果检查就不发到钉钉了； ps:健康也发到钉钉，鼓励开发继续保持；
@@ -728,4 +729,24 @@ function postReportData(data) {
     console.log("推送报告数据:" + error.message);
     //console.log(error);
   });
+}
+
+function postBaseData(data0, gspxData) {
+  axios({
+    method: 'post',
+    url: config.baseWebHost + '/apis/data_customs/save',
+    data: {
+      customs1: gspxData.customs1,
+      customs2: gspxData.customs2,
+      branchName: data0.branchName,
+      projectName: data0.projectName
+    },
+    headers: { 'Content-Type': 'application/json' }
+  }).then(function(response) {
+    console.log("推送customs数据");
+    console.log(response.data);
+  }).catch(function(error) {
+    console.log("推送customs数据:" + error.message);
+    console.log(error);
+  });
 }

package/tool/openFileWatcher.config.js

@@ -0,0 +1,150 @@
+/*
+  打开文件监听器配置文件
+  用于配置监听行为和处理规则
+*/
+
+module.exports = {
+  // 基本配置
+  enabled: true, // 是否启用打开文件监听
+  
+  // 监听的文件扩展名
+  watchExtensions: [
+    '.js',
+    '.css', 
+    '.html',
+    '.gspx'
+  ],
+  
+  // 忽略的文件和目录模式
+  ignored: [
+    // 目录
+    /node_modules/,
+    /\.git/,
+    /\.cache/,
+    /\.tmp/,
+    /dist/,
+    /build/,
+    /coverage/,
+    /\.nyc_output/,
+    
+    // 文件模式
+    /\.min\.(js|css)$/,
+    /\.bundle\.(js|css)$/,
+    /\.chunk\.(js|css)$/,
+    /\.map$/,
+    /\.d\.ts$/,
+    /\.test\.(js)$/,
+    /\.spec\.(js)$/,
+    
+    // 临时文件
+    /~$/,
+    /\.tmp$/,
+    /\.temp$/,
+    /\.swp$/,
+    /\.swo$/,
+    
+    // 系统文件
+    /\.DS_Store$/,
+    /Thumbs\.db$/,
+    /desktop\.ini$/
+  ],
+  
+  // 防抖配置
+  debounce: {
+    delay: 300, // 防抖延迟时间（毫秒）
+    maxWait: 1000 // 最大等待时间（毫秒）
+  },
+  
+  // 自动检测配置
+  autoDetection: {
+    enabled: true, // 是否启用自动检测
+    timeWindow: 24 * 60 * 60 * 1000, // 检测时间窗口（24小时）
+    maxFiles: 50, // 最大自动检测文件数
+    scanDepth: 5 // 扫描目录深度
+  },
+  
+  // 文件类型处理配置
+  handlers: {
+    javascript: {
+      extensions: ['.js'],
+      hotReload: true, // 是否支持热重载
+      syntaxCheck: false, // 是否进行语法检查
+      autoFormat: false, // 是否自动格式化
+      buildTrigger: true // 是否触发构建
+    },
+    
+    stylesheet: {
+      extensions: ['.css'],
+      hotReload: true,
+      autoCompile: false, // 是否自动编译预处理器
+      minify: false, // 是否自动压缩
+      buildTrigger: false
+    },
+    
+    template: {
+      extensions: ['.html', '.gspx'],
+      hotReload: true,
+      validateSyntax: false, // 是否验证语法
+      buildTrigger: true
+    }
+  },
+  
+  // 通知配置
+  notifications: {
+    enabled: true, // 是否启用通知
+    showFileChanges: true, // 是否显示文件变化通知
+    showErrors: true, // 是否显示错误通知
+    showStats: false, // 是否显示统计信息
+    
+    // 通知级别
+    levels: {
+      info: true,
+      warning: true,
+      error: true,
+      debug: false
+    }
+  },
+  
+  // 性能配置
+  performance: {
+    maxOpenFiles: 100, // 最大监听文件数
+    maxChangeQueue: 50, // 最大变化队列长度
+    cleanupInterval: 5 * 60 * 1000, // 清理间隔（5分钟）
+    memoryThreshold: 100 * 1024 * 1024 // 内存阈值（100MB）
+  },
+  
+  // 集成配置
+  integration: {
+    // 与现有刷新系统的集成
+    browserRefresh: {
+      enabled: true,
+      delay: 500, // 刷新延迟
+      selective: true // 是否选择性刷新
+    },
+  },
+  
+  // 日志配置
+  logging: {
+    enabled: true,
+    level: 'info', // debug, info, warn, error
+    file: null, // 日志文件路径，null 表示控制台输出
+    maxSize: 10 * 1024 * 1024, // 最大日志文件大小（10MB）
+    maxFiles: 5, // 最大日志文件数
+    
+    // 日志格式
+    format: {
+      timestamp: true,
+      level: true,
+      message: true,
+      metadata: false
+    }
+  },
+  
+  // 开发模式配置
+  development: {
+    verbose: false, // 详细输出
+    debugMode: false, // 调试模式
+    profiling: false, // 性能分析
+    mockData: false // 使用模拟数据
+  },
+};

package/tool/openFileWatcher.js

@@ -0,0 +1,760 @@
+/*
+  comment: 开发目录中打开文件的监听器
+  功能: 监听当前开发目录中打开的文件变化，支持热重载和自动构建
+*/
+
+var chokidar = require('chokidar');
+var path = require('path');
+var fs = require('fs');
+var utils = require('../lib/utils.js');
+var config = require('../lib/config.js');
+var eslint = require('eslint');
+var jschardet = require('iconv-jschardet');
+var chalk = require('chalk');
+
+/**
+ * 打开文件监听器类
+ * 专门用于监听开发目录中当前打开的文件
+ */
+class OpenFileWatcher {
+  constructor(options = {}) {
+    this.options = {
+      // 监听的文件扩展名
+      watchExtensions: ['.js', '.css', '.html', '.gspx'],
+      // 忽略的目录和文件
+      ignored: [
+        /node_modules/,
+        /\.git/,
+        /\.cache/,
+        /\.tmp/,
+        /dist/,
+        /build/,
+        /\.min\.(js|css)$/,
+        /\.bundle\.(js|css)$/
+      ],
+      // 防抖延迟时间（毫秒）
+      debounceDelay: 300,
+      // 是否启用详细日志
+      verbose: false,
+      // 自定义处理器
+      handlers: {},
+      ...options
+    };
+    
+    this.watcher = null;
+    this.isWatching = false;
+    this.openFiles = new Set(); // 当前打开的文件
+    this.changeQueue = new Map(); // 变化队列
+    this.debounceTimers = new Map(); // 防抖定时器
+    
+    // 绑定方法
+    this.handleFileChange = this.handleFileChange.bind(this);
+    this.processFileChange = this.processFileChange.bind(this);
+  }
+
+  /**
+   * 开始监听指定目录
+   * @param {string} watchPath - 要监听的目录路径
+   */
+  start(watchPath = config.webPath) {
+    if (this.isWatching) {
+      utils.log('文件监听器已在运行中...');
+      return this;
+    }
+
+    if (!watchPath || !fs.existsSync(watchPath)) {
+      throw new Error(`监听路径不存在: ${watchPath}`);
+    }
+
+    this.watchPath = path.resolve(watchPath);
+    utils.log(`开始监听开发目录: ${this.watchPath}`);
+
+    // 创建 chokidar 监听器
+    this.watcher = chokidar.watch(this.watchPath, {
+      ignored: this.options.ignored,
+      persistent: true,
+      ignoreInitial: true,
+      followSymlinks: true,
+      depth: 10,
+      awaitWriteFinish: {
+        stabilityThreshold: 200,
+        pollInterval: 100
+      }
+    });
+
+    // 绑定事件监听器
+    this.watcher
+      .on('ready', () => {
+        this.isWatching = true;
+        utils.log('文件监听器已就绪');
+        this.scanOpenFiles();
+      })
+      .on('change', (filePath) => {
+        this.handleFileChange('change', filePath);
+      })
+      .on('add', (filePath) => {
+        this.handleFileChange('add', filePath);
+      })
+      .on('unlink', (filePath) => {
+        this.handleFileChange('unlink', filePath);
+        this.openFiles.delete(filePath);
+      })
+      .on('error', (error) => {
+        utils.log(`文件监听错误: ${error.message}`);
+      });
+
+    return this;
+  }
+
+  /**
+   * 停止监听
+   */
+  stop() {
+    if (this.watcher) {
+      this.watcher.close();
+      this.isWatching = false;
+      this.openFiles.clear();
+      this.changeQueue.clear();
+      
+      // 清理所有防抖定时器
+      this.debounceTimers.forEach(timer => clearTimeout(timer));
+      this.debounceTimers.clear();
+      
+      utils.log('文件监听器已停止');
+    }
+    return this;
+  }
+
+  /**
+   * 添加要监听的打开文件
+   * @param {string|Array} filePaths - 文件路径或路径数组
+   */
+  addOpenFile(filePaths) {
+    const paths = Array.isArray(filePaths) ? filePaths : [filePaths];
+    
+    paths.forEach(filePath => {
+      const absolutePath = path.resolve(filePath);
+      if (this.shouldWatchFile(absolutePath)) {
+        this.openFiles.add(absolutePath);
+        if (this.options.verbose) {
+          utils.debug(`添加监听文件: ${absolutePath}`);
+        }
+      }
+    });
+    
+    return this;
+  }
+
+  /**
+   * 移除监听的打开文件
+   * @param {string|Array} filePaths - 文件路径或路径数组
+   */
+  removeOpenFile(filePaths) {
+    const paths = Array.isArray(filePaths) ? filePaths : [filePaths];
+    
+    paths.forEach(filePath => {
+      const absolutePath = path.resolve(filePath);
+      this.openFiles.delete(absolutePath);
+      if (this.options.verbose) {
+        utils.debug(`移除监听文件: ${absolutePath}`);
+      }
+    });
+    
+    return this;
+  }
+
+  /**
+   * 获取当前监听的打开文件列表
+   * @returns {Array} 文件路径数组
+   */
+  getOpenFiles() {
+    return Array.from(this.openFiles);
+  }
+
+  /**
+   * 扫描并自动检测可能打开的文件
+   * 基于最近修改时间和文件类型
+   */
+  scanOpenFiles() {
+    if (!this.watchPath) return;
+
+    try {
+      const recentFiles = this.findRecentlyModifiedFiles(this.watchPath, 24 * 60 * 60 * 1000); // 24小时内
+      recentFiles.forEach(filePath => {
+        if (this.shouldWatchFile(filePath)) {
+          this.openFiles.add(filePath);
+        }
+      });
+      
+      utils.log(`自动检测到 ${this.openFiles.size} 个可能打开的文件`);
+    } catch (error) {
+      utils.debug(`扫描打开文件时出错: ${error.message}`);
+    }
+  }
+
+  /**
+   * 查找最近修改的文件
+   * @param {string} dir - 目录路径
+   * @param {number} timeWindow - 时间窗口（毫秒）
+   * @returns {Array} 文件路径数组
+   */
+  findRecentlyModifiedFiles(dir, timeWindow) {
+    const recentFiles = [];
+    const now = Date.now();
+    
+    const scanDir = (dirPath) => {
+      try {
+        const items = fs.readdirSync(dirPath);
+        
+        items.forEach(item => {
+          const itemPath = path.join(dirPath, item);
+          const stats = fs.statSync(itemPath);
+          
+          if (stats.isDirectory()) {
+            // 递归扫描子目录（限制深度）
+            if (this.shouldScanDirectory(itemPath)) {
+              scanDir(itemPath);
+            }
+          } else if (stats.isFile()) {
+            // 检查文件是否在时间窗口内修改过
+            if (now - stats.mtime.getTime() < timeWindow) {
+              recentFiles.push(itemPath);
+            }
+          }
+        });
+      } catch (error) {
+        // 忽略权限错误等
+      }
+    };
+    
+    scanDir(dir);
+    return recentFiles;
+  }
+
+  /**
+   * 处理文件变化事件
+   * @param {string} event - 事件类型
+   * @param {string} filePath - 文件路径
+   */
+  handleFileChange(event, filePath) {
+    const absolutePath = path.resolve(filePath);
+    
+    // 只处理打开的文件或符合条件的文件
+    if (!this.openFiles.has(absolutePath) && !this.shouldAutoWatch(absolutePath)) {
+      return;
+    }
+
+    // 防抖处理
+    const fileKey = absolutePath;
+    if (this.debounceTimers.has(fileKey)) {
+      clearTimeout(this.debounceTimers.get(fileKey));
+    }
+
+    this.debounceTimers.set(fileKey, setTimeout(() => {
+      this.processFileChange(event, absolutePath);
+      this.debounceTimers.delete(fileKey);
+    }, this.options.debounceDelay));
+  }
+
+  /**
+   * 处理文件变化
+   * @param {string} event - 事件类型
+   * @param {string} filePath - 文件路径
+   */
+  processFileChange(event, filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    const relativePath = path.relative(this.watchPath, filePath);
+
+    // 简化的基本信息输出
+    const timestamp = new Date().toLocaleTimeString();
+    const fileSize = this.getFileSize(filePath);
+
+    console.log(chalk.cyan(`\n[${timestamp}] ${filePath} (${event}) - ${fileSize}`));
+
+    // 如果是 JavaScript 文件变化，执行代码检测
+    if (event === 'change' && ext === '.js') {
+      console.log(chalk.blue('开始检测 JavaScript 文件...'));
+      // 异步执行检测，不阻塞主流程
+      this.checkJavaScriptFile(filePath, relativePath).catch(error => {
+        console.log(chalk.red(`检测失败: ${error.message}`));
+      });
+    } else if (event === 'change') {
+      // 其他文件类型的简单提示
+      this.logFileTypeInfo(ext, event, relativePath);
+    }
+  }
+
+  /**
+   * 根据文件类型显示日志信息
+   * @param {string} ext - 文件扩展名
+   * @param {string} event - 事件类型
+   * @param {string} relativePath - 相对路径
+   */
+  logFileTypeInfo(ext, event, relativePath) {
+    switch (ext) {
+      case '.js':
+        console.log(chalk.yellow('JavaScript 文件变动'));
+        break;
+
+      case '.css':
+        console.log(chalk.blue('CSS 文件变动'));
+        break;
+
+      case '.html':
+      case '.gspx':
+        console.log(chalk.green('模板文件变动'));
+        break;
+
+      default:
+        console.log(chalk.gray('文件变动'));
+    }
+  }
+
+  /**
+   * 检查 JavaScript 文件
+   * @param {string} filePath - 文件路径
+   * @param {string} relativePath - 相对路径
+   */
+  async checkJavaScriptFile(filePath, relativePath) {
+    try {
+      // 读取文件内容
+      const byte = fs.readFileSync(filePath);
+      let content = byte.toString();
+      content = utils.toUtf8(byte);
+
+      // 快速检查
+      const encoding = this.checkFileEncoding(byte);
+      const sizeCheck = this.checkFileSize(filePath);
+
+      // ESLint 检查
+      const eslintResults = await this.eslintCheck(content);
+      const eslintSummary = this.processEslintResults(eslintResults);
+
+      // 兼容性检查
+      const compatSummary = this.checkDangerousSyntax(content);
+
+      // 汇总输出
+      this.printCheckSummary(relativePath, encoding, sizeCheck, eslintSummary, compatSummary);
+
+    } catch (error) {
+      console.log(`❌ 检测失败: ${error.message}`);
+    }
+  }
+
+  /**
+   * 检查文件编码
+   * @param {Buffer} byte - 文件字节
+   * @returns {Object} 编码检查结果
+   */
+  checkFileEncoding(byte) {
+    try {
+      const ret = jschardet.detect(byte);
+      const content = byte.toString();
+
+      if (utils.isUtf8(byte, ret.encoding) || ret.encoding == 'UTF-8') {
+        return { encoding: 'UTF-8', status: 'ok', message: 'UTF-8' };
+      } else {
+        const reg = /[\u4e00-\u9FA5]+/;
+        if (!reg.test(content)) {
+          return { encoding: 'UTF-8', status: 'ok', message: 'UTF-8 (无中文)' };
+        } else {
+          return { encoding: ret.encoding, status: 'warning', message: `${ret.encoding} (建议改为 UTF-8)` };
+        }
+      }
+    } catch (error) {
+      return { encoding: '未知', status: 'error', message: `检查失败: ${error.message}` };
+    }
+  }
+
+  /**
+   * 检查文件大小
+   * @param {string} filePath - 文件路径
+   * @returns {Object} 文件大小检查结果
+   */
+  checkFileSize(filePath) {
+    try {
+      const stats = fs.statSync(filePath);
+      const sizeKB = stats.size / 1024;
+      const threshold = 300; // 300KB 阈值
+
+      if (sizeKB > threshold) {
+        return {
+          size: sizeKB.toFixed(2),
+          status: 'warning',
+          message: `${sizeKB.toFixed(2)}KB (超过 ${threshold}KB)`
+        };
+      } else {
+        return {
+          size: sizeKB.toFixed(2),
+          status: 'ok',
+          message: `${sizeKB.toFixed(2)}KB`
+        };
+      }
+    } catch (error) {
+      return {
+        size: '未知',
+        status: 'error',
+        message: `检查失败: ${error.message}`
+      };
+    }
+  }
+
+  /**
+   * ESLint 检查
+   * @param {string} content - 文件内容
+   * @returns {Array} 检查结果
+   */
+  async eslintCheck(content) {
+    try {
+      const options = {
+        cwd: __dirname,
+        overrideConfig: {
+          globals: {
+            'crabadoc': 'readonly'
+          }
+        }
+      };
+
+      // 添加配置的全局变量
+      const globals = config.globals;
+      if (globals) {
+        globals.forEach(key => {
+          options.overrideConfig.globals[key] = 'readonly';
+        });
+      }
+
+      // 自动添加 namespace 的全局对象
+      const strs = content.match(/Type\.registerNamespace\((.*?)\)/g);
+      if (strs && strs.length > 0) {
+        strs.forEach((str) => {
+          const names = str.substring(24, str.length - 2).split('.');
+          const namespace = names[0];
+          options.overrideConfig.globals[namespace] = 'readonly';
+        });
+      }
+
+      // 混淆后的变量通配符
+      for (let i = 0; i < 300; i++) {
+        const key = '_Z_' + i;
+        options.overrideConfig.globals[key] = 'writable';
+      }
+
+      const lint = new eslint.ESLint(options);
+      const res = await lint.lintText(content);
+      return res;
+    } catch (error) {
+      console.log(`❌ ESLint 检查失败: ${error.message}`);
+      return [];
+    }
+  }
+
+  /**
+   * 处理 ESLint 检查结果
+   * @param {Array} eslintResults - ESLint 结果
+   * @returns {Object} 检查结果汇总
+   */
+  processEslintResults(eslintResults) {
+    if (!eslintResults || eslintResults.length === 0) {
+      return { status: 'no-result', total: 0, errors: 0, warnings: 0, issues: [] };
+    }
+
+    const result = eslintResults[0];
+    if (!result.messages || result.messages.length === 0) {
+      return { status: 'ok', total: 0, errors: 0, warnings: 0, issues: [] };
+    }
+
+    let errorCount = 0;
+    let warningCount = 0;
+    let undefCount = 0;
+    const issues = [];
+
+    result.messages.forEach((item) => {
+      // 忽略 $ 开头的全局变量
+      const reg = new RegExp(/'\$\w+'\sis\snot\sdefined\./);
+      if (reg.test(item.message)) {
+        return;
+      }
+
+      let type = '提示';
+      let severity = 'info';
+
+      if (!item.ruleId) {
+        type = '解析失败';
+        severity = 'error';
+        errorCount++;
+      } else if (item.ruleId.includes('no-undef') || item.ruleId.includes('no-dupe-keys')) {
+        type = '未定义';
+        severity = 'warning';
+        undefCount++;
+      } else if (item.ruleId.includes('native-ie')) {
+        type = '兼容性';
+        severity = 'error';
+        errorCount++;
+      } else if (item.ruleId.indexOf('no-unused-vars') > -1) {
+        if (item.message && (item.message.includes("'sender'") || item.message.includes("'eventArgs'") || item.message.includes("'args'"))) {
+          return;
+        }
+        type = '未使用';
+        severity = 'info';
+      } else {
+        type = '警告';
+        severity = 'warning';
+        warningCount++;
+      }
+
+      issues.push({
+        type,
+        severity,
+        line: item.line,
+        column: item.column,
+        message: item.message,
+        ruleId: item.ruleId
+      });
+    });
+
+    return {
+      status: errorCount > 0 ? 'error' : (warningCount > 0 || undefCount > 0) ? 'warning' : 'ok',
+      total: issues.length,
+      errors: errorCount,
+      warnings: warningCount,
+      undefined: undefCount,
+      issues: issues.slice(0, 3) // 只返回前3个问题
+    };
+  }
+
+  /**
+   * 检查危险语法
+   * @param {string} content - 文件内容
+   * @returns {Object} 兼容性检查结果
+   */
+  checkDangerousSyntax(content) {
+    // 危险语法规则
+    const dangerousJs = ['\\slet\\s', '\\sconst\\s', '\=\>\\s?\\(?\\{', '\\sasync\\s', '\\sawait\\s', '\\.then\\(', '\\sdebugger\\s'];
+
+    const reg = new RegExp(dangerousJs.join('|'));
+    const noComment = utils.clearComment(content); // 去掉注释的代码
+
+    if (reg.test(noComment)) {
+      const nreg = new RegExp(dangerousJs.join('|'), 'ig');
+      const matches = [...noComment.matchAll(nreg)];
+
+      return {
+        status: 'warning',
+        hasES6: true,
+        count: matches.length,
+        samples: matches.slice(0, 3).map(match => ({
+          syntax: match[0].trim(),
+          position: match.index
+        }))
+      };
+    } else {
+      return {
+        status: 'ok',
+        hasES6: false,
+        count: 0,
+        samples: []
+      };
+    }
+  }
+
+  /**
+   * 打印检查汇总
+   * @param {string} relativePath - 相对路径
+   * @param {Object} encoding - 编码检查结果
+   * @param {Object} sizeCheck - 大小检查结果
+   * @param {Object} eslintSummary - ESLint 检查结果
+   * @param {Object} compatSummary - 兼容性检查结果
+   */
+  printCheckSummary(relativePath, encoding, sizeCheck, eslintSummary, compatSummary) {
+    // 获取颜色化的状态文本
+    const getColoredStatus = (status, message) => {
+      switch (status) {
+        case 'ok': return chalk.green(message);
+        case 'warning': return chalk.yellow(message);
+        case 'error': return chalk.red(message);
+        default: return chalk.gray(message);
+      }
+    };
+
+    // 简化的一行汇总
+    const encodingText = getColoredStatus(encoding.status, `编码: ${encoding.message}`);
+    const sizeText = getColoredStatus(sizeCheck.status, `大小: ${sizeCheck.message}`);
+    const eslintText = getColoredStatus(eslintSummary.status, `语法: ${this.getEslintSummary(eslintSummary)}`);
+    const compatText = getColoredStatus(compatSummary.status, `兼容性: ${this.getCompatSummary(compatSummary)}`);
+
+    console.log(`   ${encodingText} | ${sizeText} | ${eslintText} | ${compatText}`);
+
+    // 如果有严重问题，显示详细信息
+    if (eslintSummary.status === 'error' || eslintSummary.errors > 0) {
+      console.log(chalk.red('   严重问题详情:'));
+      eslintSummary.issues.filter(issue => issue.severity === 'error').forEach(issue => {
+        console.log(chalk.red(`      第${issue.line}行: ${issue.message}`));
+      });
+    }
+
+    // 如果有兼容性问题，显示详情
+    if (compatSummary.hasES6 && compatSummary.samples.length > 0) {
+      console.log(chalk.yellow(`   兼容性问题: ${compatSummary.samples.map(s => s.syntax).join(', ')}`));
+    }
+  }
+
+  /**
+   * 获取 ESLint 汇总信息
+   * @param {Object} summary - ESLint 检查结果
+   * @returns {string} 汇总信息
+   */
+  getEslintSummary(summary) {
+    if (summary.status === 'no-result') return '无结果';
+    if (summary.status === 'ok') return '无问题';
+
+    const parts = [];
+    if (summary.errors > 0) parts.push(`${summary.errors}错误`);
+    if (summary.warnings > 0) parts.push(`${summary.warnings}警告`);
+    if (summary.undefined > 0) parts.push(`${summary.undefined}未定义`);
+
+    return parts.join(',') || `${summary.total}问题`;
+  }
+
+  /**
+   * 获取兼容性汇总信息
+   * @param {Object} summary - 兼容性检查结果
+   * @returns {string} 汇总信息
+   */
+  getCompatSummary(summary) {
+    if (summary.hasES6) {
+      return `发现${summary.count}个ES6+语法`;
+    }
+    return '无ES6+语法';
+  }
+
+  /**
+   * 获取文件大小
+   * @param {string} filePath - 文件路径
+   * @returns {string} 格式化的文件大小
+   */
+  getFileSize(filePath) {
+    try {
+      const stats = fs.statSync(filePath);
+      const bytes = stats.size;
+
+      if (bytes === 0) return '0 B';
+
+      const k = 1024;
+      const sizes = ['B', 'KB', 'MB', 'GB'];
+      const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+      return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+    } catch (error) {
+      return '未知';
+    }
+  }
+
+  /**
+   * 判断是否应该监听该文件
+   * @param {string} filePath - 文件路径
+   * @returns {boolean}
+   */
+  shouldWatchFile(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return this.options.watchExtensions.includes(ext) && 
+           !this.isIgnored(filePath);
+  }
+
+  /**
+   * 判断是否应该自动监听该文件
+   * @param {string} filePath - 文件路径
+   * @returns {boolean}
+   */
+  shouldAutoWatch(filePath) {
+    // 可以根据需要实现自动监听逻辑
+    // 例如：最近修改的文件、特定模式的文件等
+    return false;
+  }
+
+  /**
+   * 判断是否应该扫描该目录
+   * @param {string} dirPath - 目录路径
+   * @returns {boolean}
+   */
+  shouldScanDirectory(dirPath) {
+    return !this.isIgnored(dirPath);
+  }
+
+  /**
+   * 判断路径是否被忽略
+   * @param {string} filePath - 文件路径
+   * @returns {boolean}
+   */
+  isIgnored(filePath) {
+    return this.options.ignored.some(pattern => {
+      if (pattern instanceof RegExp) {
+        return pattern.test(filePath);
+      }
+      return filePath.includes(pattern);
+    });
+  }
+
+  /**
+   * 简单的事件发射器
+   * @param {string} event - 事件名
+   * @param {*} data - 事件数据
+   */
+  emit(event, data) {
+    // 这里可以集成到现有的事件系统中
+    // 或者通过 WebSocket 发送到前端
+    if (config.refresh && global.socketBroadcast) {
+      global.socketBroadcast(JSON.stringify({
+        mode: 'openFileChange',
+        event: event,
+        data: data
+      }));
+    }
+  }
+
+  /**
+   * 获取监听状态
+   * @returns {boolean}
+   */
+  isActive() {
+    return this.isWatching;
+  }
+
+  /**
+   * 获取监听统计信息
+   * @returns {Object}
+   */
+  getStats() {
+    return {
+      isWatching: this.isWatching,
+      watchPath: this.watchPath,
+      openFilesCount: this.openFiles.size,
+      queuedChanges: this.changeQueue.size,
+      activeTimers: this.debounceTimers.size
+    };
+  }
+}
+
+// 导出类和工厂函数
+module.exports = {
+  OpenFileWatcher,
+  
+  /**
+   * 创建打开文件监听器实例
+   * @param {Object} options - 配置选项
+   * @returns {OpenFileWatcher}
+   */
+  createWatcher(options) {
+    return new OpenFileWatcher(options);
+  },
+  
+  /**
+   * 快速启动打开文件监听
+   * @param {string} watchPath - 监听路径
+   * @param {Object} options - 配置选项
+   * @returns {OpenFileWatcher}
+   */
+  startWatching(watchPath, options = {}) {
+    const watcher = new OpenFileWatcher(options);
+    return watcher.start(watchPath);
+  }
+};