@raphaellcs/data-cleaner 1.0.0 → 2.0.0

package/README.md

@@ -1,4 +1,7 @@
-# @claw-dev/data-cleaner
+# @raphaellcs/data-cleaner
+[![npm](https://img.shields.io/npm/v/@raphaellcs/data-cleaner)](https://www.npmjs.com/package/@raphaellcs/data-cleaner)
+[![downloads](https://img.shields.io/npm/dm/@raphaellcs/data-cleaner)](https://www.npmjs.com/package/@raphaellcs/data-cleaner)
+[![license](https://img.shields.io/npm/l/@raphaellcs/data-cleaner)](https://www.npmjs.com/package/@raphaellcs/data-cleaner)
 
 > 数据清洗工具 - 快速清洗和转换数据文件
 
@@ -13,6 +16,9 @@
 - **排序**：按列排序
 - **格式转换**：JSON ↔ CSV
 - **统计信息**：查看数据概况
+- **数据验证**：内置验证规则和自定义规则（新）
+- **分组聚合**：字段分组和时间分组（新）
+- **透视表**：创建数据透视表（新）
 
 ## 📦 安装
 
@@ -296,11 +302,134 @@ done
 ## 🚧 待实现
 
 - [ ] 支持更多文件格式（Excel、SQL）
-- [ ] 自定义转换函数
-- [ ] 正则表达式替换
-- [ ] 数据验证规则
 - [ ] 合并多个文件
-- [ ] 分组统计
+
+---
+
+## ✨ 新功能（v2.0.0）
+
+### 数据验证
+
+验证数据是否符合规则：
+
+```bash
+data-cleaner validate data.csv --config rules.json
+```
+
+创建验证规则配置 `rules.json`：
+
+```json
+{
+  "email": ["required", "email"],
+  "age": [
+    "required",
+    {"name": "number", "message": "年龄必须是数字"},
+    {"name": "min", "value": 0, "message": "年龄不能为负数"},
+    {"name": "max", "value": 120, "message": "年龄不能超过120"}
+  ],
+  "phone": [
+    {"name": "pattern", "value": "^\\d{11}$", "message": "手机号必须是11位数字"}
+  ],
+  "status": [
+    {"name": "enum", "value": ["active", "inactive", "pending"], "message": "状态值不合法"}
+  ]
+}
+```
+
+**内置验证规则：**
+- `required` - 必填
+- `email` - 邮箱格式
+- `url` - URL 格式
+- `number` - 数字
+- `integer` - 整数
+- `positive` - 正数
+- `negative` - 负数
+- `min:<value>` - 最小值
+- `max:<value>` - 最大值
+- `minLength:<length>` - 最小长度
+- `maxLength:<length>` - 最大长度
+- `pattern:<regex>` - 正则匹配
+- `enum:[values]` - 枚举值
+- `date` - 日期
+- `future` - 未来日期
+- `past` - 过去日期
+- `phone` - 电话号码
+
+输出错误报告：
+
+```bash
+data-cleaner validate data.csv --config rules.json --output errors.csv --format csv
+```
+
+### 分组聚合
+
+按字段分组并聚合：
+
+```bash
+# 按部门分组，计算平均工资
+data-cleaner group employees.csv --group-by department --aggregate "salary:avg" --stats
+
+# 多字段分组
+data-cleaner group sales.csv --group-by "region,category" --aggregate "revenue:sum,count" --output grouped.json
+```
+
+时间分组：
+
+```bash
+# 按天分组
+data-cleaner group orders.csv --time-field created_at --interval day --aggregate "amount:sum" --stats
+
+# 按月分组
+data-cleaner group orders.csv --time-field created_at --interval month --aggregate "amount:sum,count" --stats
+
+# 按小时分组
+data-cleaner group logs.csv --time-field timestamp --interval hour --aggregate "errors:sum" --stats
+```
+
+**聚合类型：**
+- `sum` - 求和
+- `avg` - 平均值
+- `min` - 最小值
+- `max` - 最大值
+- `count` - 计数
+- `count_distinct` - 去重计数
+- `first` - 第一个值
+- `last` - 最后一个值
+- `concat` - 拼接
+- `array` - 数组
+- `percentile:XX` - 百分位数（如 percentile:95）
+
+### 透视表
+
+创建数据透视表：
+
+```bash
+data-cleaner pivot sales.csv \
+  --rows region \
+  --columns product \
+  --values revenue \
+  --agg sum
+```
+
+示例输出：
+
+```
+    productA    productB    productC
+region1      15000.00    23000.00    18000.00
+region2      12000.00    25000.00    21000.00
+region3      18000.00    20000.00    22000.00
+```
+
+保存透视表：
+
+```bash
+data-cleaner pivot sales.csv \
+  --rows region \
+  --columns product \
+  --values revenue \
+  --agg sum \
+  --output pivot.json
+```
 
 ## 🤝 贡献
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@raphaellcs/data-cleaner",
-  "version": "1.0.0",
-  "description": "数据清洗工具 - 快速清洗和转换数据文件",
+  "version": "2.0.0",
+  "description": "数据清洗工具 - 验证、分组、透视表",
   "main": "src/index.js",
   "bin": {
     "data-cleaner": "./bin/cli.js"

package/src/grouper.js

@@ -0,0 +1,360 @@
+// 分组统计模块
+
+/**
+ * 按字段分组
+ * @param {Array} data - 数据数组
+ * @param {string} groupByField - 分组字段
+ * @returns {Object} 分组结果
+ */
+function groupBy(data, groupByField) {
+  const groups = {};
+
+  for (const item of data) {
+    const key = item[groupByField];
+    if (groups[key] === undefined) {
+      groups[key] = [];
+    }
+    groups[key].push(item);
+  }
+
+  return groups;
+}
+
+/**
+ * 按多个字段分组
+ * @param {Array} data - 数据数组
+ * @param {Array<string>} groupByFields - 分组字段数组
+ * @returns {Object} 分组结果
+ */
+function groupByMultiple(data, groupByFields) {
+  const groups = {};
+
+  for (const item of data) {
+    const keyParts = groupByFields.map(field => {
+      const value = item[field];
+      return value !== undefined && value !== null ? String(value) : '__null__';
+    });
+    const key = keyParts.join('|');
+
+    if (groups[key] === undefined) {
+      groups[key] = [];
+    }
+    groups[key].push(item);
+  }
+
+  return groups;
+}
+
+/**
+ * 计算组的统计信息
+ * @param {Array} group - 组数据
+ * @param {Object} aggregations - 聚合规则
+ * @returns {Object} 统计结果
+ */
+function aggregateGroup(group, aggregations) {
+  const result = {};
+
+  for (const [fieldName, aggType] of Object.entries(aggregations)) {
+    const values = group
+      .map(item => item[fieldName])
+      .filter(v => v !== null && v !== undefined && v !== '');
+
+    switch (aggType) {
+      case 'sum':
+        result[fieldName] = values.reduce((sum, v) => sum + (Number(v) || 0), 0);
+        break;
+
+      case 'avg':
+        result[fieldName] = values.length > 0
+          ? values.reduce((sum, v) => sum + (Number(v) || 0), 0) / values.length
+          : 0;
+        break;
+
+      case 'min':
+        result[fieldName] = Math.min(...values.map(v => Number(v) || Infinity));
+        break;
+
+      case 'max':
+        result[fieldName] = Math.max(...values.map(v => Number(v) || -Infinity));
+        break;
+
+      case 'count':
+        result[fieldName] = values.length;
+        break;
+
+      case 'count_distinct':
+        result[fieldName] = new Set(values).size;
+        break;
+
+      case 'first':
+        result[fieldName] = values[0];
+        break;
+
+      case 'last':
+        result[fieldName] = values[values.length - 1];
+        break;
+
+      case 'concat':
+        result[fieldName] = values.join(', ');
+        break;
+
+      case 'array':
+        result[fieldName] = values;
+        break;
+
+      default:
+        if (aggType.startsWith('percentile:')) {
+          const p = parseInt(aggType.split(':')[1]);
+          result[fieldName] = calculatePercentile(values.map(v => Number(v)), p);
+        }
+    }
+  }
+
+  return result;
+}
+
+/**
+ * 计算百分位数
+ * @param {Array<number>} values - 数值数组
+ * @param {number} percentile - 百分位数（0-100）
+ * @returns {number}
+ */
+function calculatePercentile(values, percentile) {
+  if (values.length === 0) return 0;
+
+  const sorted = [...values].sort((a, b) => a - b);
+  const index = (percentile / 100) * (sorted.length - 1);
+
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  const weight = index - lower;
+
+  if (upper >= sorted.length) {
+    return sorted[sorted.length - 1];
+  }
+
+  return sorted[lower] * (1 - weight) + sorted[upper] * weight;
+}
+
+/**
+ * 分组并聚合
+ * @param {Array} data - 数据数组
+ * @param {string|Array<string>} groupBy - 分组字段
+ * @param {Object} aggregations - 聚合规则
+ * @returns {Array} 分组聚合结果
+ */
+function groupAndAggregate(data, groupBy, aggregations) {
+  const groupByFields = Array.isArray(groupBy) ? groupBy : [groupBy];
+  const groups = groupByMultiple(data, groupByFields);
+
+  const result = [];
+
+  for (const [key, group] of Object.entries(groups)) {
+    const keyParts = key.split('|');
+
+    const groupResult = {
+      _group: key,
+      _count: group.length
+    };
+
+    // 添加分组字段
+    groupByFields.forEach((field, index) => {
+      groupResult[field] = keyParts[index] === '__null__' ? null : keyParts[index];
+    });
+
+    // 添加聚合结果
+    const aggResults = aggregateGroup(group, aggregations);
+    Object.assign(groupResult, aggResults);
+
+    result.push(groupResult);
+  }
+
+  return result;
+}
+
+/**
+ * 按时间分组
+ * @param {Array} data - 数据数组
+ * @param {string} dateField - 日期字段
+ * @param {string} interval - 时间间隔（day/week/month/year/hour/minute）
+ * @returns {Object} 分组结果
+ */
+function groupByTime(data, dateField, interval = 'day') {
+  const groups = {};
+
+  for (const item of data) {
+    const date = new Date(item[dateField]);
+    if (isNaN(date.getTime())) continue;
+
+    let key;
+    switch (interval) {
+      case 'minute':
+        key = date.toISOString().substring(0, 16); // YYYY-MM-DDTHH:MM
+        break;
+      case 'hour':
+        key = date.toISOString().substring(0, 13); // YYYY-MM-DDTHH
+        break;
+      case 'day':
+        key = date.toISOString().substring(0, 10); // YYYY-MM-DD
+        break;
+      case 'week':
+        const weekStart = new Date(date);
+        weekStart.setDate(date.getDate() - date.getDay());
+        key = weekStart.toISOString().substring(0, 10);
+        break;
+      case 'month':
+        key = date.toISOString().substring(0, 7); // YYYY-MM
+        break;
+      case 'year':
+        key = date.toISOString().substring(0, 4); // YYYY
+        break;
+      default:
+        key = date.toISOString().substring(0, 10);
+    }
+
+    if (!groups[key]) {
+      groups[key] = [];
+    }
+    groups[key].push(item);
+  }
+
+  return groups;
+}
+
+/**
+ * 计算分组统计信息
+ * @param {Object} groups - 分组结果
+ * @param {string} statField - 统计字段
+ * @returns {Array} 统计信息
+ */
+function getGroupStats(groups, statField) {
+  const stats = [];
+
+  for (const [key, group] of Object.entries(groups)) {
+    const values = group
+      .map(item => Number(item[statField]))
+      .filter(v => !isNaN(v));
+
+    if (values.length === 0) {
+      stats.push({
+        group: key,
+        count: 0,
+        sum: 0,
+        avg: 0,
+        min: 0,
+        max: 0
+      });
+      continue;
+    }
+
+    stats.push({
+      group: key,
+      count: values.length,
+      sum: values.reduce((sum, v) => sum + v, 0),
+      avg: values.reduce((sum, v) => sum + v, 0) / values.length,
+      min: Math.min(...values),
+      max: Math.max(...values)
+    });
+  }
+
+  return stats.sort((a, b) => a.group.localeCompare(b.group));
+}
+
+/**
+ * 数据透视表
+ * @param {Array} data - 数据数组
+ * @param {string} rowField - 行字段
+ * @param {string} columnField - 列字段
+ * @param {string} valueField - 值字段
+ * @param {string} aggFunction - 聚合函数（sum/avg/count/min/max）
+ * @returns {Object} 透视表
+ */
+function pivotTable(data, rowField, columnField, valueField, aggFunction = 'sum') {
+  const rows = new Set();
+  const columns = new Set();
+  const values = {};
+
+  // 收集行、列和值
+  for (const item of data) {
+    const rowKey = item[rowField];
+    const colKey = item[columnField];
+    const val = Number(item[valueField]) || 0;
+
+    rows.add(rowKey);
+    columns.add(colKey);
+
+    const key = `${rowKey}::${colKey}`;
+    if (!values[key]) {
+      values[key] = [];
+    }
+    values[key].push(val);
+  }
+
+  // 计算聚合值
+  const pivot = {};
+
+  for (const row of rows) {
+    pivot[row] = {};
+    for (const col of columns) {
+      const key = `${row}::${col}`;
+      const vals = values[key] || [];
+
+      let aggValue;
+      switch (aggFunction) {
+        case 'sum':
+          aggValue = vals.reduce((sum, v) => sum + v, 0);
+          break;
+        case 'avg':
+          aggValue = vals.length > 0 ? vals.reduce((sum, v) => sum + v, 0) / vals.length : 0;
+          break;
+        case 'count':
+          aggValue = vals.length;
+          break;
+        case 'min':
+          aggValue = vals.length > 0 ? Math.min(...vals) : 0;
+          break;
+        case 'max':
+          aggValue = vals.length > 0 ? Math.max(...vals) : 0;
+          break;
+        default:
+          aggValue = vals.reduce((sum, v) => sum + v, 0);
+      }
+
+      pivot[row][col] = aggValue;
+    }
+  }
+
+  return {
+    rows: Array.from(rows).sort(),
+    columns: Array.from(columns).sort(),
+    data: pivot
+  };
+}
+
+/**
+ * 打印分组统计
+ * @param {Array} stats - 统计信息
+ */
+function printGroupStats(stats) {
+  console.log('\n📊 分组统计\n');
+
+  for (const stat of stats) {
+    console.log(`${stat.group}:`);
+    console.log(`  数量: ${stat.count}`);
+    console.log(`  总和: ${stat.sum.toFixed(2)}`);
+    console.log(`  平均: ${stat.avg.toFixed(2)}`);
+    console.log(`  最小: ${stat.min.toFixed(2)}`);
+    console.log(`  最大: ${stat.max.toFixed(2)}`);
+    console.log();
+  }
+}
+
+module.exports = {
+  groupBy,
+  groupByMultiple,
+  groupAndAggregate,
+  groupByTime,
+  getGroupStats,
+  pivotTable,
+  printGroupStats
+};

package/src/index.js

@@ -6,6 +6,17 @@ const { program } = require('commander');
 const chalk = require('chalk');
 const { parse } = require('csv-parse');
 const { stringify } = require('csv-stringify');
+const {
+  DataValidator,
+  createValidatorFromConfig
+} = require('./validator.js');
+const {
+  groupAndAggregate,
+  groupByTime,
+  getGroupStats,
+  pivotTable,
+  printGroupStats
+} = require('./grouper.js');
 
 // 读取文件
 function readFile(filePath) {
@@ -347,23 +358,23 @@ program
       console.log(chalk.red(`文件不存在: ${input}`));
       process.exit(1);
     }
-    
+
     const ext = path.extname(input).toLowerCase();
     const outputFormat = options.format || (ext === '.json' ? 'json' : 'csv');
     const outputFile = output || input.replace(/\.[^.]+$/, `.cleaned.${outputFormat}`);
-    
+
     console.log(chalk.cyan(`\n🔧 清洗数据\n`));
     console.log(chalk.gray(`输入: ${input}`));
     console.log(chalk.gray(`输出: ${outputFile}\n`));
-    
+
     const data = await readFile(input);
-    
+
     // 显示原始统计
     if (options.stats) {
       console.log(chalk.cyan('原始数据:'));
       printStats(getStats(data));
     }
-    
+
     // 解析过滤表达式
     if (options.filter) {
       const parts = options.filter.split(':');
@@ -391,29 +402,267 @@ program
     if (options.columns) {
       options.columns = options.columns.split(',');
     }
-    
+
     // 清洗数据
     const cleaned = cleanData(data, options);
-    
+
     // 显示清洗后统计
     if (options.stats) {
       console.log(chalk.cyan('清洗后数据:'));
       printStats(getStats(cleaned));
     }
-    
+
     // 写入文件
     await writeFile(outputFile, cleaned, outputFormat);
-    
+
     console.log(chalk.green(`✅ 已保存到: ${outputFile}`));
-    
+
     // 显示差异
     const originalCount = Array.isArray(data) ? data.length : 1;
     const cleanedCount = Array.isArray(cleaned) ? cleaned.length : 1;
     if (originalCount !== cleanedCount) {
       console.log(chalk.yellow(`   从 ${originalCount} 行减少到 ${cleanedCount} 行`));
     }
-    
+
+    console.log();
+  });
+
+// 验证命令
+program
+  .command('validate <input>')
+  .option('-c, --config <path>', '验证规则配置文件（JSON）')
+  .option('-o, --output <path>', '输出错误报告到文件')
+  .option('--format <type>', '输出格式（json/csv）', 'json')
+  .description('验证数据')
+  .action(async (input, options) => {
+    if (!fs.existsSync(input)) {
+      console.log(chalk.red(`文件不存在: ${input}`));
+      process.exit(1);
+    }
+
+    const data = await readFile(input);
+
+    if (!Array.isArray(data)) {
+      console.log(chalk.red('数据必须是数组格式'));
+      process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n✅ 验证数据\n`));
+
+    let validator;
+
+    // 从配置文件加载规则
+    if (options.config) {
+      if (!fs.existsSync(options.config)) {
+        console.log(chalk.red(`配置文件不存在: ${options.config}`));
+        process.exit(1);
+      }
+      const configContent = fs.readFileSync(options.config, 'utf-8');
+      const config = JSON.parse(configContent);
+      validator = createValidatorFromConfig(config);
+      console.log(chalk.gray(`从配置文件加载规则: ${options.config}`));
+    } else {
+      // 没有配置，提示用户
+      console.log(chalk.yellow('未提供验证规则配置，跳过验证'));
+      console.log(chalk.gray('使用 --config 指定验证规则文件\n'));
+      process.exit(0);
+    }
+
+    console.log(chalk.gray(`规则数量: ${validator.getRuleCount()}`));
+    console.log();
+
+    // 执行验证
+    const errors = validator.getErrors(data);
+
+    if (errors.length === 0) {
+      console.log(chalk.green('✓ 所有数据验证通过！\n'));
+    } else {
+      console.log(chalk.red(`✗ 发现 ${errors.length} 个验证错误:\n`));
+
+      // 显示前 20 个错误
+      const displayErrors = errors.slice(0, 20);
+      for (const error of displayErrors) {
+        console.log(chalk.red(`  [行 ${error.row}] ${error.field}`));
+        console.log(chalk.gray(`    规则: ${error.rule}`));
+        console.log(chalk.gray(`    值: ${error.value}`));
+        console.log(chalk.gray(`    消息: ${error.message}\n`));
+      }
+
+      if (errors.length > 20) {
+        console.log(chalk.yellow(`... 还有 ${errors.length - 20} 个错误\n`));
+      }
+    }
+
+    // 输出错误报告
+    if (options.output && errors.length > 0) {
+      if (options.format === 'csv') {
+        const headers = ['row', 'field', 'rule', 'value', 'message'];
+        const rows = errors.map(e => [
+          e.row, e.field, e.rule,
+          `"${String(e.value).replace(/"/g, '""')}"`,
+          `"${e.message.replace(/"/g, '""')}"`
+        ]);
+        const csv = [headers.join(','), ...rows.map(r => r.join(','))].join('\n');
+        fs.writeFileSync(options.output, csv, 'utf-8');
+      } else {
+        fs.writeFileSync(options.output, JSON.stringify(errors, null, 2), 'utf-8');
+      }
+      console.log(chalk.green(`✓ 错误报告已保存到: ${options.output}\n`));
+    }
+
+    process.exit(errors.length === 0 ? 0 : 1);
+  });
+
+// 分组命令
+program
+  .command('group <input>')
+  .option('-g, --group-by <field>', '分组字段（支持多个，逗号分隔）')
+  .option('-a, --aggregate <expr>', '聚合表达式（field:aggType，逗号分隔）')
+  .option('-t, --time-field <field>', '时间字段（用于时间分组）')
+  .option('-i, --interval <type>', '时间间隔（minute/hour/day/week/month/year）', 'day')
+  .option('-o, --output <path>', '输出文件')
+  .option('-f, --format <type>', '输出格式（json/csv）', 'json')
+  .option('--stats', '显示统计信息')
+  .description('分组和聚合数据')
+  .action(async (input, options) => {
+    if (!fs.existsSync(input)) {
+      console.log(chalk.red(`文件不存在: ${input}`));
+      process.exit(1);
+    }
+
+    const data = await readFile(input);
+
+    if (!Array.isArray(data)) {
+      console.log(chalk.red('数据必须是数组格式'));
+      process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n📊 分组和聚合\n`));
+
+    let result;
+
+    // 时间分组
+    if (options.timeField) {
+      const groups = groupByTime(data, options.timeField, options.interval);
+      console.log(chalk.gray(`时间字段: ${options.timeField}`));
+      console.log(chalk.gray(`时间间隔: ${options.interval}`));
+      console.log(chalk.gray(`分组数量: ${Object.keys(groups).length}\n`));
+
+      if (options.stats && options.aggregate) {
+        const aggParts = options.aggregate.split(',');
+        const aggregations = {};
+        for (const part of aggParts) {
+          const [field, aggType] = part.split(':');
+          aggregations[field] = aggType;
+        }
+
+        const stats = getGroupStats(groups, Object.keys(aggregations)[0]);
+        printGroupStats(stats);
+
+        // 转换为数组输出
+        result = groupAndAggregate(data, options.timeField, aggregations);
+      } else {
+        result = groups;
+      }
+    } else if (options.groupBy) {
+      // 字段分组
+      const groupByFields = options.groupBy.split(',');
+      const aggregations = {};
+
+      if (options.aggregate) {
+        const aggParts = options.aggregate.split(',');
+        for (const part of aggParts) {
+          const [field, aggType] = part.split(':');
+          aggregations[field] = aggType;
+        }
+      }
+
+      console.log(chalk.gray(`分组字段: ${groupByFields.join(', ')}`));
+      console.log(chalk.gray(`聚合规则: ${Object.keys(aggregations).join(', ') || '无'}\n`));
+
+      result = groupAndAggregate(data, groupByFields, aggregations);
+
+      // 显示结果
+      if (options.stats) {
+        for (const item of result) {
+          console.log(chalk.cyan(`  ${item._group}`));
+          console.log(chalk.gray(`    数量: ${item._count}`));
+          for (const [key, value] of Object.entries(item)) {
+            if (!key.startsWith('_')) {
+              console.log(chalk.gray(`    ${key}: ${typeof value === 'number' ? value.toFixed(2) : value}`));
+            }
+          }
+          console.log();
+        }
+      }
+    } else {
+      console.log(chalk.red('必须指定 --group-by 或 --time-field'));
+      process.exit(1);
+    }
+
+    // 输出文件
+    if (options.output) {
+      if (options.format === 'csv') {
+        await writeFile(options.output, result, 'csv');
+      } else {
+        fs.writeFileSync(options.output, JSON.stringify(result, null, 2), 'utf-8');
+      }
+      console.log(chalk.green(`✓ 已保存到: ${options.output}\n`));
+    }
+  });
+
+// 透视表命令
+program
+  .command('pivot <input>')
+  .option('-r, --rows <field>', '行字段')
+  .option('-c, --columns <field>', '列字段')
+  .option('-v, --values <field>', '值字段')
+  .option('-a, --agg <func>', '聚合函数（sum/avg/count/min/max）', 'sum')
+  .option('-o, --output <path>', '输出文件')
+  .description('创建数据透视表')
+  .action(async (input, options) => {
+    if (!fs.existsSync(input)) {
+      console.log(chalk.red(`文件不存在: ${input}`));
+      process.exit(1);
+    }
+
+    if (!options.rows || !options.columns || !options.values) {
+      console.log(chalk.red('必须指定 --rows, --columns 和 --values'));
+      process.exit(1);
+    }
+
+    const data = await readFile(input);
+
+    if (!Array.isArray(data)) {
+      console.log(chalk.red('数据必须是数组格式'));
+      process.exit(1);
+    }
+
+    console.log(chalk.cyan(`\n📊 数据透视表\n`));
+    console.log(chalk.gray(`行: ${options.rows}`));
+    console.log(chalk.gray(`列: ${options.columns}`));
+    console.log(chalk.gray(`值: ${options.values}`));
+    console.log(chalk.gray(`聚合: ${options.agg}\n`));
+
+    const pivot = pivotTable(data, options.rows, options.columns, options.values, options.agg);
+
+    // 打印透视表
+    console.log(chalk.cyan(`    ${pivot.columns.join('        ')}`));
+    for (const row of pivot.rows) {
+      const rowData = [row];
+      for (const col of pivot.columns) {
+        const value = pivot.data[row][col];
+        rowData.push((typeof value === 'number' ? value.toFixed(2) : value).padStart(12));
+      }
+      console.log(chalk.cyan(rowData.join('  ')));
+    }
     console.log();
+
+    // 输出文件
+    if (options.output) {
+      fs.writeFileSync(options.output, JSON.stringify(pivot, null, 2), 'utf-8');
+      console.log(chalk.green(`✓ 已保存到: ${options.output}\n`));
+    }
   });
 
 program.parse();

package/src/validator.js

@@ -0,0 +1,298 @@
+// 数据验证模块
+
+/**
+ * 验证规则类
+ */
+class ValidationRule {
+  constructor(name, validator, errorMessage) {
+    this.name = name;
+    this.validator = validator;
+    this.errorMessage = errorMessage;
+  }
+}
+
+/**
+ * 内置验证规则
+ */
+const BUILT_IN_RULES = {
+  required: (value) => {
+    return value !== null && value !== undefined && value !== '';
+  },
+  email: (value) => {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(value);
+  },
+  url: (value) => {
+    try {
+      new URL(value);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  number: (value) => {
+    return !isNaN(parseFloat(value)) && isFinite(value);
+  },
+  integer: (value) => {
+    return Number.isInteger(Number(value));
+  },
+  positive: (value) => {
+    return Number(value) > 0;
+  },
+  negative: (value) => {
+    return Number(value) < 0;
+  },
+  min: (value, min) => {
+    return Number(value) >= min;
+  },
+  max: (value, max) => {
+    return Number(value) <= max;
+  },
+  minLength: (value, min) => {
+    return String(value).length >= min;
+  },
+  maxLength: (value, max) => {
+    return String(value).length <= max;
+  },
+  pattern: (value, pattern) => {
+    return new RegExp(pattern).test(value);
+  },
+  enum: (value, values) => {
+    return values.includes(value);
+  },
+  date: (value) => {
+    return !isNaN(Date.parse(value));
+  },
+  future: (value) => {
+    return new Date(value) > new Date();
+  },
+  past: (value) => {
+    return new Date(value) < new Date();
+  },
+  phone: (value) => {
+    // 简单的电话号码验证（国际）
+    const phoneRegex = /^\+?[\d\s-()]+$/;
+    return phoneRegex.test(value) && value.replace(/\D/g, '').length >= 10;
+  }
+};
+
+/**
+ * 数据验证器
+ */
+class DataValidator {
+  constructor() {
+    this.rules = new Map(); // fieldName -> ValidationRule[]
+    this.customRules = new Map();
+  }
+
+  /**
+   * 添加内置规则
+   * @param {string} fieldName - 字段名
+   * @param {string} ruleName - 规则名
+   * @param {*} args - 规则参数
+   * @param {string} errorMessage - 自定义错误信息
+   */
+  addRule(fieldName, ruleName, args, errorMessage) {
+    if (!this.rules.has(fieldName)) {
+      this.rules.set(fieldName, []);
+    }
+
+    const validator = (value) => {
+      const ruleFn = BUILT_IN_RULES[ruleName];
+      if (!ruleFn) {
+        throw new Error(`未知规则: ${ruleName}`);
+      }
+
+      // 规则参数
+      if (args !== undefined && args !== null) {
+        return ruleFn(value, args);
+      }
+
+      return ruleFn(value);
+    };
+
+    this.rules.get(fieldName).push(new ValidationRule(
+      ruleName,
+      validator,
+      errorMessage
+    ));
+  }
+
+  /**
+   * 添加自定义规则
+   * @param {string} ruleName - 规则名
+   * @param {Function} validator - 验证函数
+   */
+  addCustomRule(ruleName, validator) {
+    this.customRules.set(ruleName, validator);
+  }
+
+  /**
+   * 添加正则规则
+   * @param {string} fieldName - 字段名
+   * @param {string} pattern - 正则表达式
+   * @param {string} errorMessage - 错误信息
+   */
+  addPatternRule(fieldName, pattern, errorMessage) {
+    this.addRule(fieldName, 'pattern', pattern, errorMessage);
+  }
+
+  /**
+   * 验证单个字段
+   * @param {string} fieldName - 字段名
+   * @param {*} value - 字段值
+   * @returns {Object} 验证结果 { valid: boolean, errors: Array }
+   */
+  validateField(fieldName, value) {
+    const errors = [];
+    const rules = this.rules.get(fieldName) || [];
+
+    for (const rule of rules) {
+      try {
+        const isValid = rule.validator(value);
+        if (!isValid) {
+          errors.push({
+            rule: rule.name,
+            message: rule.errorMessage || `${fieldName} 验证失败: ${rule.name}`
+          });
+        }
+      } catch (error) {
+        errors.push({
+          rule: rule.name,
+          message: `${fieldName} 验证错误: ${error.message}`
+        });
+      }
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * 验证整个数据对象
+   * @param {Object} data - 数据对象
+   * @returns {Object} 验证结果 { valid: boolean, fieldResults: Object }
+   */
+  validate(data) {
+    const fieldResults = {};
+    let isValid = true;
+
+    for (const [fieldName] of this.rules) {
+      const result = this.validateField(fieldName, data[fieldName]);
+      fieldResults[fieldName] = result;
+      if (!result.valid) {
+        isValid = false;
+      }
+    }
+
+    return {
+      valid: isValid,
+      fieldResults
+    };
+  }
+
+  /**
+   * 验证数据数组
+   * @param {Array} dataArray - 数据数组
+   * @returns {Array} 验证结果数组
+   */
+  validateArray(dataArray) {
+    return dataArray.map((data, index) => ({
+      index,
+      ...this.validate(data)
+    }));
+  }
+
+  /**
+   * 批量验证并返回错误记录
+   * @param {Array} dataArray - 数据数组
+   * @returns {Array} 错误记录
+   */
+  getErrors(dataArray) {
+    const errors = [];
+
+    for (let i = 0; i < dataArray.length; i++) {
+      const validation = this.validate(dataArray[i]);
+      if (!validation.valid) {
+        for (const [fieldName, result] of Object.entries(validation.fieldResults)) {
+          if (!result.valid) {
+            for (const error of result.errors) {
+              errors.push({
+                row: i,
+                field: fieldName,
+                rule: error.rule,
+                message: error.message,
+                value: dataArray[i][fieldName]
+              });
+            }
+          }
+        }
+      }
+    }
+
+    return errors;
+  }
+
+  /**
+   * 清除所有规则
+   */
+  clear() {
+    this.rules.clear();
+  }
+
+  /**
+   * 获取规则数量
+   * @returns {number}
+   */
+  getRuleCount() {
+    let count = 0;
+    for (const rules of this.rules.values()) {
+      count += rules.length;
+    }
+    return count;
+  }
+}
+
+/**
+ * 从配置创建验证器
+ * @param {Object} config - 验证配置
+ * @returns {DataValidator}
+ */
+function createValidatorFromConfig(config) {
+  const validator = new DataValidator();
+
+  for (const [fieldName, fieldRules] of Object.entries(config)) {
+    if (Array.isArray(fieldRules)) {
+      for (const rule of fieldRules) {
+        if (typeof rule === 'string') {
+          // 简单规则名
+          validator.addRule(fieldName, rule);
+        } else if (typeof rule === 'object') {
+          // 带参数的规则
+          const args = rule.value !== undefined ? rule.value :
+                      rule.arg !== undefined ? rule.arg :
+                      rule.params;
+          const errorMessage = rule.message;
+
+          validator.addRule(
+            fieldName,
+            rule.name || rule.type || rule.rule,
+            args,
+            errorMessage
+          );
+        }
+      }
+    }
+  }
+
+  return validator;
+}
+
+module.exports = {
+  DataValidator,
+  ValidationRule,
+  BUILT_IN_RULES,
+  createValidatorFromConfig
+};

package/validation-rules.json

@@ -0,0 +1,16 @@
+{
+  "email": ["required", "email"],
+  "age": [
+    "required",
+    {"name": "number"},
+    {"name": "min", "value": 0},
+    {"name": "max", "value": 120}
+  ],
+  "phone": [
+    "required",
+    {"name": "pattern", "value": "^\\d{11}$", "message": "手机号必须是11位数字"}
+  ],
+  "status": [
+    {"name": "enum", "value": ["active", "inactive", "pending"]}
+  ]
+}