@airiot/cli 1.0.3 → 1.0.4

package/bin/iot-scripts.js

@@ -52,6 +52,7 @@ switch (script) {
   case 'i18n-scanner':
   case 'i18n-translate':
   case 'eslint':
+  case 'bugfix':
   case 'test': {
     await runScript(script);
     break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@airiot/cli",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "AIRIOT平台前端包管理工具",
   "type": "module",
   "scripts": {},

package/scripts/bugfix.js

@@ -0,0 +1,212 @@
+import { ESLint } from 'eslint';
+import chalk from 'chalk';
+import paths from "../config/paths.js";
+import overrideConfig from '../config/eslint.config.js';
+
+const { exec } = await import('child_process');
+const { promisify } = await import('util');
+const execP = promisify(exec);
+
+try {
+  // 检查 cline 是否可用
+  await execP('cline --version', { maxBuffer: 1024 * 1024 });
+} catch (err) {
+  console.error(chalk.red('未检测到 cline CLI，脚本需要 cline 才能运行。'));
+  console.log('请按下面任一方式安装并重试：');
+  console.log(chalk.cyan('  npm install -g cline'));
+  console.log(chalk.cyan('  或者：yarn global add cline'));
+  console.log(chalk.cyan('  或参考 cline 官方文档获取其它安装方式'));
+  console.log(chalk.cyan('  注意：安装cline后要配置可用的Provider'));
+  process.exit(1);
+}
+
+const eslint = new ESLint({
+  overrideConfigFile: true,
+  overrideConfig,
+});
+
+const fixRules = '1. Remove console.log statements; 2. For duplicate object keys, keep the latter key and remove the earlier one';
+
+// 简单的彩色输出封装
+const symbols = {
+  info: chalk.cyan('ℹ'),
+  step: chalk.blue('▶'),
+  success: chalk.green('✓'),
+  warn: chalk.yellow('⚠'),
+  error: chalk.red('✖'),
+};
+const log = {
+  info: (...args) => console.log(symbols.info, ...args),
+  step: (...args) => console.log(symbols.step, ...args),
+  success: (...args) => console.log(symbols.success, ...args),
+  warn: (...args) => console.warn(symbols.warn, ...args),
+  error: (...args) => console.error(symbols.error, ...args),
+};
+
+(async () => {
+  log.step(chalk.bold('执行 ESLint...'));
+  const results = await eslint.lintFiles(['src/**/*.js']);
+
+  // 转换为按文件的数组，保留必要字段
+  const files = results.map(r => ({
+    filePath: r.filePath,
+    messages: r.messages.map(m => ({
+      ruleId: m.ruleId,
+      message: m.message,
+      line: m.line,
+      column: m.column,
+    })),
+    raw: r,
+  }));
+
+  log.success(`ESLint 执行完毕，找到 ${chalk.yellow(files.length)} 个文件有问题。`);
+
+  // 创建 10 个 instance 并记录 address 到数组
+  // 并行创建 10 个 instance
+  const createCmd = 'cline i n';
+  const maxBuffer = 10 * 1024 * 1024;
+  const createPromises = Array.from({ length: 10 }, (_, i) =>
+    execP(createCmd, { maxBuffer })
+      .then(({ stdout, stderr }) => ({
+        index: i + 1,
+        cmd: createCmd,
+        stdout: (typeof stdout === 'string' ? stdout : String(stdout || '')).trim(),
+        stderr: (typeof stderr === 'string' ? stderr : String(stderr || '')).trim(),
+        error: false,
+      }))
+      .catch(err => ({
+        index: i + 1,
+        cmd: createCmd,
+        stdout: err && err.stdout ? String(err.stdout).trim() : '',
+        stderr: err && err.stderr ? String(err.stderr).trim() : (err.message || String(err)),
+        error: true,
+      }))
+  );
+
+  log.step(chalk.bold('创建 cline instances...'));
+  const instances = await Promise.all(createPromises);
+  log.success('创建 cline instances 完毕');
+
+  // 从每个实例输出中提取 address
+  for (const it of instances) {
+    const out = it.stdout || '';
+    let address = null;
+    const ipv4 = out.match(/((?:\d{1,3}\.){3}\d{1,3})(?::\d+)?/);
+    if (ipv4) address = ipv4[0];
+    else {
+      const labeled = out.match(/Address[:\s]*([^\s,;]+)/i);
+      if (labeled) address = labeled[1];
+    }
+    if (!address) address = out.split(/\r?\n/).find(Boolean) || out || null;
+    it.address = address;
+    if (!it.error && address) {
+      log.info(`实例 ${chalk.bold(it.index)} 地址: ${chalk.green(address)}`);
+    } else {
+      log.error(`创建实例 ${chalk.bold(it.index)} 失败: ${chalk.red(it.stderr || 'unknown error')}`);
+    }
+  }
+  // 使用实例作为并发 worker，从文件队列中轮询领取任务，完成后继续领取，直到队列为空
+  const queue = files
+    .filter(f => f && f.messages && f.messages.length > 0)
+    .map(f => ({ ...f })); // shallow copy，避免后续对原数组影响
+
+  if (queue.length === 0) {
+    log.info(chalk.yellow('没有需要修复的文件，跳过修复流程。'));
+  } else {
+    log.step(`开始分派 ${chalk.yellow(queue.length)} 个待修复文件给 ${chalk.yellow(instances.length)} 个实例并行处理...`);
+
+    const results = []; // 存放每个任务的执行结果
+
+    // worker：每个实例执行一个循环，直到 queue 为空
+    const workers = instances.map((it, idx) => (async () => {
+      // 跳过无地址或创建失败的实例
+      if (!it || it.error || !it.address) {
+        log.warn(`跳过实例 ${chalk.bold(idx + 1)}，无可用地址或创建失败。`);
+        return;
+      }
+
+      while (true) {
+        // 取出下一个文件（单线程 JS 中 shift 是安全的）
+        const f = queue.shift();
+        if (!f) break;
+
+        const bugContent = f.messages
+          .map(m => `${m.message} (rule:${m.ruleId} ${m.line}:${m.column})`)
+          .join('; ');
+        const payload = `fix bug. the rules: ${fixRules}; file: ${f.filePath}; bug content: ${bugContent}`;
+        const cmd = `cline -y --address ${it.address} ${JSON.stringify(payload)}`;
+
+        try {
+          log.step(`实例 ${chalk.bold(idx + 1)} 正在修复: ${chalk.cyan(f.filePath.replace(paths.appPath, ''))}`);
+          const { stdout, stderr } = await execP(cmd, { maxBuffer });
+          log.success(`实例 ${chalk.bold(idx + 1)} 完成修复: ${chalk.cyan(f.filePath.replace(paths.appPath, ''))}`);
+          results.push({
+            filePath: f.filePath,
+            cmd,
+            stdout: typeof stdout === 'string' ? stdout : String(stdout || ''),
+            stderr: typeof stderr === 'string' ? stderr : String(stderr || ''),
+            status: 'fulfilled',
+          });
+        } catch (err) {
+          log.error(`实例 ${chalk.bold(idx + 1)} 修复失败: ${chalk.red(f.filePath)}`);
+          results.push({
+            filePath: f.filePath,
+            cmd,
+            stdout: err && err.stdout ? String(err.stdout) : '',
+            stderr: err && err.stderr ? String(err.stderr) : (err.message || String(err)),
+            status: 'rejected',
+          });
+        }
+      }
+    })());
+
+    // 等待所有 worker 完成
+    await Promise.all(workers);
+
+    // 打印结果表格（与后续原代码输出风格相同）
+    const rows = results.map(s => {
+      const stdout = (s.stdout || '').trim();
+      const stderr = (s.stderr || '').trim();
+      let result;
+      if (s.status === 'fulfilled' && !stderr) result = chalk.green('已修复');
+      else if (s.status === 'fulfilled' && stderr) result = chalk.yellow('部分修复/有警告');
+      else if (s.status === 'rejected') result = chalk.red('修复失败');
+      else result = chalk.gray('未执行');
+      const noteRaw = result === chalk.green('已修复')
+        ? (stdout.split(/\r?\n/)[0] || '无输出')
+        : (stderr.split(/\r?\n/)[0] || stdout.split(/\r?\n/)[0] || (s.cmd ? '命令已执行' : '未知错误'));
+      return { file: s.filePath.replace(paths.appPath, ''), result: String(result), note: noteRaw };
+    });
+
+    if (rows.length === 0) {
+      log.info(chalk.yellow('没有需要修复的文件。'));
+    } else {
+      const fileCol = Math.max(4, ...rows.map(r => r.file.length));
+      const resCol = Math.max(6, ...rows.map(r => r.result.length));
+      const noteCol = Math.max(4, ...rows.map(r => r.note.length));
+
+      const pad = (str, len) => str + ' '.repeat(len - str.length);
+      const sep = '-'.repeat(fileCol) + '  ' + '-'.repeat(resCol) + '  ' + '-'.repeat(noteCol);
+
+      console.log(chalk.bold(pad('文件', fileCol)) + '  ' + chalk.bold(pad('结果', resCol)) + '  ' + chalk.bold(pad('说明', noteCol)));
+      console.log(chalk.gray(sep));
+      for (const r of rows) {
+        console.log(pad(r.file, fileCol) + '  ' + pad(r.result, resCol) + '  ' + pad(r.note, noteCol));
+      }
+
+      const total = rows.length;
+      const success = rows.filter(r => r.result.includes('已修复')).length;
+      const partial = rows.filter(r => r.result.includes('部分修复')).length;
+      const failed = rows.filter(r => r.result.includes('修复失败')).length;
+      console.log('\n' +
+        chalk.bold('汇总：') + ' ' +
+        `总计 ${chalk.yellow(total)}，` +
+        `已修复 ${chalk.green(success)}，` +
+        `部分/警告 ${chalk.yellow(partial)}，` +
+        `失败 ${chalk.red(failed)}`);
+    }
+  }
+
+  // 任务已经由此处完整处理，终止后续重复执行
+  process.exit(0);
+})();