@qwe8652591/abap-recursive-query 1.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 824000672@qq.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,223 @@
+# AI Build Download - Redis 队列系统
+
+基于 Redis 队列 + 生产者-消费者模式的 ABAP 递归查询下载系统。
+
+## 🎯 核心特性
+
+- ✅ **高性能**: 查询次数减少50%，速度提升3-10倍，过滤规则性能提升20倍
+- ✅ **可扩展**: 支持水平扩展，100+并发消费者，优化的连接管理
+- ✅ **可靠性**: 任务持久化，自动重试，断点续传
+- ✅ **零硬编码**: 通用设计，适用于任何 SAP GUI 程序
+- ✅ **资源优化**: Redis连接减少99%，内存占用大幅降低
+
+## 📁 项目结构
+
+```
+src/
+├── common/          # 通用组件（类型、配置、队列管理、工具函数）
+├── producer/        # 生产者（并发递归查询，内存队列）
+├── consumer/        # 消费者（文件下载，Redis队列）
+└── cli/             # CLI 工具
+    ├── query-object.ts    # 单体模式（推荐）
+    ├── producer-cli.ts    # 只启动生产者
+    └── consumer-cli.ts    # 只启动消费者
+```
+
+## 🚀 快速开始
+
+### 1. 环境准备
+
+```bash
+# 安装 Redis
+docker run -d --name redis -p 6379:6379 redis:latest
+
+# 安装依赖
+pnpm install
+```
+
+### 2. 配置环境变量
+
+复制 `env.example` 到 `.env` 并修改：
+
+```bash
+cp env.example .env
+```
+
+最少配置（`.env`）：
+
+```env
+# SAP 连接（必需）
+SAP_URL=https://your-sap-system.com:8000
+SAP_USERNAME=your_username
+SAP_PASSWORD=your_password
+SAP_CLIENT=100
+
+# Redis 连接
+REDIS_HOST=localhost
+REDIS_PORT=6379
+```
+
+更多配置选项请参考 `env.example` 文件。
+
+### 3. 使用
+
+#### 方式一：单体模式（推荐）
+
+```bash
+pnpm build
+pnpm query -- PROGRAM SAPLMEGUI -d 3
+
+# 带过滤规则
+pnpm query -- CLASS CL_MY_CLASS -d 5 -e Z_OLD -x "*_TEST"
+```
+
+#### 方式二：分离模式（高性能）
+
+```bash
+# 终端1：启动生产者
+pnpm build
+pnpm producer -- PROGRAM SAPLMEGUI -d 3
+# 输出: Job ID: abc-123-def
+
+# 终端2：启动消费者
+pnpm consumer -- --job-id abc-123-def -c 50
+
+# 或启动多个消费者进程实现水平扩展
+pnpm consumer -- -c 50  # 进程1
+pnpm consumer -- -c 50  # 进程2
+pnpm consumer -- -c 50  # 进程3
+```
+
+## 🏗️ 架构说明
+
+### 工作流程
+
+```
+用户请求
+   ↓
+Producer（生产者）
+├─ 并发递归查询（10并发，内存队列）
+├─ 提取依赖关系
+├─ 缓存对象数据（gzip压缩）
+└─ 生成任务 → Redis 队列
+   ↓
+Consumers（消费者集群）
+├─ 从 Redis 拉取任务
+├─ 读取缓存数据
+├─ 下载源代码
+└─ 处理附加数据（Include、结构体、屏幕等）
+```
+
+### 核心组件
+
+- **common/RedisQueueManager**: 队列和缓存管理
+- **producer/RecursiveQueryProducer**: 递归查询（内存队列）
+- **consumer/FileDownloadConsumer**: 文件下载（Redis队列）
+
+## 📊 性能对比
+
+| 指标 | 旧实现 | 新实现（10消费者） | 新实现（150消费者） | 提升 |
+|------|--------|------------------|-------------------|------|
+| 150对象耗时 | 22.5秒 | 7.5秒 | 2秒 | 最高10倍 |
+| 查询次数 | 300次 | 150次 | 150次 | 减少50% |
+| 并发能力 | 20 | 100+ | 100+ | 5倍+ |
+
+## 📦 API 使用
+
+```typescript
+import { 
+    RedisQueueManager,
+    RecursiveQueryProducer,
+    FileDownloadConsumer 
+} from '@qwe8652591/ai-build-download';
+
+// 创建组件
+const queueManager = new RedisQueueManager();
+const producer = new RecursiveQueryProducer(queueManager);
+
+// 提交查询
+const jobId = await producer.submitQuery('PROGRAM', 'SAPLMEGUI', config);
+
+// 启动消费者
+const consumer = new FileDownloadConsumer(queueManager, './downloads', [jobId]);
+await consumer.start([jobId]);
+
+// 等待完成
+await producer.waitForCompletion(jobId);
+```
+
+## ⚙️ 环境变量
+
+| 变量 | 默认值 | 说明 |
+|------|--------|------|
+| `REDIS_HOST` | localhost | Redis 服务器地址 |
+| `REDIS_PORT` | 6379 | Redis 端口 |
+| `PRODUCER_CONCURRENCY` | 10 | 生产者并发查询数 |
+| `CONCURRENT_CONSUMERS` | 10 | 默认消费者数量 |
+| `QUEUE_MAX_SIZE` | 40 | 队列背压阈值 |
+| `MAX_RETRIES` | 3 | 最大重试次数 |
+| `CACHE_EXPIRY` | 1800 | 缓存过期时间（秒） |
+| `ENABLE_COMPRESSION` | true | 启用 gzip 压缩 |
+
+## 🎮 CLI 命令
+
+### 单体模式
+
+```bash
+# 基本查询
+pnpm query -- PROGRAM SAPLMEGUI
+
+# 带参数
+pnpm query -- -t CLASS -n CL_MY_CLASS -d 5 -c 20
+
+# 带过滤规则
+pnpm query -- PROGRAM Z_PROG -e Z_OLD -x "*_TEST" -x "*_TMP"
+
+# 完整帮助
+pnpm query -- --help
+```
+
+### 分离模式
+
+```bash
+# 生产者
+pnpm producer -- PROGRAM SAPLMEGUI -d 3
+
+# 消费者（处理特定 Job）
+pnpm consumer -- --job-id <job-id> -c 50
+
+# 消费者（处理所有活跃 Job）
+pnpm consumer -- -c 20
+```
+
+## 🐛 故障排查
+
+### Redis 连接失败
+
+```bash
+# 检查 Redis 是否运行
+redis-cli ping
+# 应该返回: PONG
+```
+
+### 查看队列状态
+
+```bash
+redis-cli
+
+# 查看所有 Job
+ZRANGE abap:job:index 0 -1
+
+# 查看队列大小
+GET abap:queue:size:<job-id>
+```
+
+## 📚 技术文档
+
+详细的技术设计和实现说明请参考：
+- [技术设计文档](../../docs/RECURSIVE_QUERY_REFACTOR_TECHNICAL_DESIGN.md)
+- [优化总结](./OPTIMIZATION_SUMMARY.md) - 最新的性能优化详情
+
+## 📄 License
+
+MIT

package/dist/cli/consumer-cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * 消费者 CLI 工具
+ * 只负责从 Redis 队列拉取任务并下载文件
+ * 可以独立部署，支持水平扩展
+ */
+export {};
+//# sourceMappingURL=consumer-cli.d.ts.map

package/dist/cli/consumer-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consumer-cli.d.ts","sourceRoot":"","sources":["../../src/cli/consumer-cli.ts"],"names":[],"mappings":";AAEA;;;;GAIG"}

package/dist/cli/consumer-cli.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * 消费者 CLI 工具
+ * 只负责从 Redis 队列拉取任务并下载文件
+ * 可以独立部署，支持水平扩展
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// ⚠️ 重要：必须在所有其他导入之前加载环境变量
+const dotenv = __importStar(require("dotenv"));
+const path_1 = require("path");
+const envPath = (0, path_1.join)(__dirname, '../../.env');
+dotenv.config({ path: envPath });
+// 加载环境变量后再导入其他模块
+const common_1 = require("../common");
+const consumer_1 = require("../consumer");
+/**
+ * 解析命令行参数
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let jobId;
+    let consumerCount = parseInt(process.env.CONCURRENT_CONSUMERS || '10');
+    let downloadPath = './downloads';
+    let organizeByProgram = true; // 默认按程序分目录
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--job-id':
+            case '-j':
+                jobId = args[++i];
+                break;
+            case '--consumers':
+            case '-c':
+                consumerCount = parseInt(args[++i]) || 10;
+                break;
+            case '--download-path':
+            case '-p':
+                downloadPath = args[++i] || './downloads';
+                break;
+            case '--organize-by-program':
+            case '-o':
+                organizeByProgram = args[++i]?.toLowerCase() !== 'false';
+                break;
+            case '--help':
+            case '-h':
+                showHelp();
+                process.exit(0);
+                break;
+        }
+    }
+    return { jobId, consumerCount, downloadPath, organizeByProgram };
+}
+function showHelp() {
+    console.error(`
+ABAP 递归查询工具 - 消费者模式
+
+用法：
+  npm run consumer -- [选项]
+
+参数：
+  --job-id, -j              指定 Job ID（可选，不指定则处理所有活跃 Job）
+  --consumers, -c           消费者数量（默认：10）
+  --download-path, -p       下载路径（默认：./downloads）
+  --organize-by-program, -o 是否按程序分目录（默认：true）
+                            true: downloads/PROGRAM_NAME/...
+                            false: downloads/...
+  --help, -h                显示帮助
+
+示例：
+  # 处理特定 Job
+  npm run consumer -- --job-id abc-123-def
+
+  # 处理所有活跃 Job（自动发现）
+  npm run consumer -- -c 20
+
+  # 不按程序分目录（所有文件在同一目录下）
+  npm run consumer -- -o false
+
+  # 水平扩展：启动多个消费者进程
+  npm run consumer -- -c 50  # 进程1
+  npm run consumer -- -c 50  # 进程2
+
+环境变量：
+  REDIS_HOST=localhost, REDIS_PORT=6379
+  CONCURRENT_CONSUMERS=10（默认消费者数量）
+
+说明：
+  此工具从 Redis 队列拉取任务并下载文件。
+  可以启动多个消费者进程实现水平扩展。
+`);
+}
+async function main() {
+    console.error('ABAP 递归查询工具 - 消费者模式\n');
+    const args = parseArgs();
+    console.error(`🔧 消费者启动`);
+    console.error(`消费者数量: ${args.consumerCount}`);
+    console.error(`下载路径: ${args.downloadPath}`);
+    console.error(`按程序分目录: ${args.organizeByProgram ? '是' : '否'}`);
+    if (args.jobId) {
+        console.error(`目标 Job: ${args.jobId}`);
+    }
+    else {
+        console.error(`模式: 处理所有活跃 Job`);
+    }
+    console.error('');
+    // 创建队列管理器
+    const queueManager = new common_1.RedisQueueManager();
+    // 获取要处理的 Job 列表
+    const jobIds = args.jobId ? [args.jobId] : await queueManager.getActiveJobIds();
+    if (jobIds.length === 0) {
+        console.error('⚠️  没有找到活跃的 Job，等待任务...');
+    }
+    else {
+        console.error(`📋 找到 ${jobIds.length} 个活跃 Job: ${jobIds.join(', ')}\n`);
+    }
+    // 启动消费者
+    const consumers = [];
+    const consumerPromises = [];
+    for (let i = 0; i < args.consumerCount; i++) {
+        const consumer = new consumer_1.FileDownloadConsumer(queueManager, args.downloadPath, jobIds.length > 0 ? jobIds : undefined, args.organizeByProgram);
+        consumers.push(consumer);
+        consumerPromises.push(consumer.start(jobIds.length > 0 ? jobIds : undefined).catch(err => {
+            console.error(`消费者 ${i + 1} 错误:`, err);
+        }));
+    }
+    console.error(`✅ ${args.consumerCount} 个消费者已启动，正在处理任务...\n`);
+    console.error('按 Ctrl+C 停止\n');
+    // 监听退出信号
+    process.on('SIGINT', async () => {
+        console.error('\n\n⏹️  收到停止信号，正在关闭消费者...');
+        for (const consumer of consumers) {
+            await consumer.stop();
+        }
+        await queueManager.close();
+        console.error('✅ 消费者已停止');
+        process.exit(0);
+    });
+    // 等待所有消费者完成（或用户中断）
+    await Promise.allSettled(consumerPromises);
+}
+if (require.main === module) {
+    main().catch(error => {
+        console.error('未捕获的错误：', error);
+        process.exit(1);
+    });
+}

package/dist/cli/producer-cli.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * 生产者 CLI 工具
+ * 只负责递归查询并生成任务，推送到 Redis 队列
+ * 可以独立部署
+ */
+export {};
+//# sourceMappingURL=producer-cli.d.ts.map

package/dist/cli/producer-cli.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"producer-cli.d.ts","sourceRoot":"","sources":["../../src/cli/producer-cli.ts"],"names":[],"mappings":";AAEA;;;;GAIG"}

package/dist/cli/producer-cli.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * 生产者 CLI 工具
+ * 只负责递归查询并生成任务，推送到 Redis 队列
+ * 可以独立部署
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+// ⚠️ 重要：必须在所有其他导入之前加载环境变量
+const dotenv = __importStar(require("dotenv"));
+const path_1 = require("path");
+const envPath = (0, path_1.join)(__dirname, '../../.env');
+dotenv.config({ path: envPath });
+// 加载环境变量后再导入其他模块
+const uuid_1 = require("uuid");
+const common_1 = require("../common");
+const producer_1 = require("../producer");
+/**
+ * 解析命令行参数
+ */
+function parseArgs() {
+    const args = process.argv.slice(2);
+    let queryType = '';
+    let queryName = '';
+    let maxDepth = 3;
+    let jobId = undefined;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        switch (arg) {
+            case '--type':
+            case '-t':
+                i++;
+                if (i >= args.length) {
+                    console.error(`错误：${arg} 参数缺少值`);
+                    process.exit(1);
+                }
+                queryType = args[i];
+                break;
+            case '--name':
+            case '-n':
+                i++;
+                if (i >= args.length) {
+                    console.error(`错误：${arg} 参数缺少值`);
+                    process.exit(1);
+                }
+                queryName = args[i];
+                break;
+            case '--max-depth':
+            case '-d':
+                i++;
+                if (i >= args.length) {
+                    console.error(`错误：${arg} 参数缺少值`);
+                    process.exit(1);
+                }
+                const depth = parseInt(args[i]);
+                if (isNaN(depth) || depth < 0) {
+                    console.error(`错误：无效的深度值 "${args[i]}"，必须是非负整数（0 表示只查询根对象）`);
+                    process.exit(1);
+                }
+                maxDepth = depth;
+                break;
+            case '--job-id':
+            case '-j':
+                jobId = args[++i];
+                break;
+            case '--help':
+            case '-h':
+                showHelp();
+                process.exit(0);
+                break;
+            default:
+                if (!arg.startsWith('-') && !queryType) {
+                    queryType = arg;
+                }
+                else if (!arg.startsWith('-') && !queryName) {
+                    queryName = arg;
+                }
+                break;
+        }
+    }
+    if (!queryType || !queryName) {
+        console.error('错误：查询类型和查询名称都是必需的参数');
+        showHelp();
+        process.exit(1);
+    }
+    return { queryType, queryName, maxDepth, jobId };
+}
+function showHelp() {
+    console.error(`
+ABAP 递归查询工具 - 生产者模式
+
+用法：
+  npm run producer -- <类型> <名称> [选项]
+
+参数：
+  --type, -t           对象类型（PROGRAM/CLASS/FUNCTION）
+  --name, -n           对象名称
+  --max-depth, -d      最大递归深度（默认：3，0 表示只查询根对象）
+  --job-id, -j         指定 Job ID（可选，不指定则自动生成）
+  --help, -h           显示帮助
+
+示例：
+  npm run producer -- PROGRAM SAPLMEGUI
+  npm run producer -- -t CLASS -n CL_MY_CLASS -d 5
+  npm run producer -- FUGR Z_MY_FUNCTION_GROUP -d 2
+  npm run producer -- -t PROGRAM -n SAPLMEGUI -d 0  # 只查询根对象
+  npm run producer -- -t PROGRAM -n SAPLMEGUI -j my-custom-job-id
+
+环境变量：
+  SAP_URL, SAP_USERNAME, SAP_PASSWORD, SAP_CLIENT
+  REDIS_HOST=localhost, REDIS_PORT=6379
+  PRODUCER_CONCURRENCY=10
+
+说明：
+  此工具只负责递归查询并生成任务，推送到 Redis 队列。
+  需要单独启动消费者（consumer-cli）来下载文件。
+  
+  使用流程：
+  1. 运行生产者，获取 Job ID（或指定自定义 Job ID）
+  2. 使用 Job ID 启动消费者
+  3. 消费者处理所有任务
+`);
+}
+/**
+ * 格式化时间（毫秒转为易读格式）
+ */
+function formatDuration(ms) {
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+    if (hours > 0) {
+        const remainingMinutes = minutes % 60;
+        const remainingSeconds = seconds % 60;
+        return `${hours}小时 ${remainingMinutes}分钟 ${remainingSeconds}秒`;
+    }
+    else if (minutes > 0) {
+        const remainingSeconds = seconds % 60;
+        return `${minutes}分钟 ${remainingSeconds}秒`;
+    }
+    else {
+        return `${seconds}秒`;
+    }
+}
+async function main() {
+    // 记录开始时间
+    const startTime = Date.now();
+    console.error('ABAP 递归查询工具 - 生产者模式\n');
+    const args = parseArgs();
+    console.error(`🏭 生产者启动`);
+    console.error(`查询对象: ${args.queryType}/${args.queryName}`);
+    console.error(`最大深度: ${args.maxDepth}`);
+    if (args.jobId) {
+        console.error(`Job ID: ${args.jobId}`);
+    }
+    console.error(`⏱️  开始时间: ${new Date().toLocaleString('zh-CN')}`);
+    console.error('');
+    const config = {
+        maxRecursionDepth: args.maxDepth,
+        downloadRootPath: './downloads',
+        downloadIncludes: true,
+        enableCircularReferenceCheck: true,
+        concurrentRequestLimit: parseInt(process.env.PRODUCER_CONCURRENCY || '10'),
+        requestInterval: 100
+    };
+    // 创建队列管理器
+    const queueManager = new common_1.RedisQueueManager();
+    // 创建生产者
+    const producer = new producer_1.RecursiveQueryProducer(queueManager);
+    try {
+        // 创建新 Job（使用指定的 jobId 或生成新的）
+        const jobId = args.jobId || (0, uuid_1.v4)();
+        console.error(`📋 创建新 Job...`);
+        if (args.jobId) {
+            console.error(`   使用指定的 Job ID: ${jobId}`);
+        }
+        else {
+            console.error(`   生成的 Job ID: ${jobId}`);
+        }
+        await producer.createJob(jobId, args.queryType.toUpperCase(), args.queryName.toUpperCase(), config);
+        console.error(`✅ Job 已创建: ${jobId}\n`);
+        // 启动递归查询（阻塞模式，等待完成）
+        console.error(`🔄 开始递归查询...\n`);
+        const queryStartTime = Date.now();
+        await producer.generateAllTasks(jobId, args.queryType.toUpperCase(), args.queryName.toUpperCase(), config);
+        // 计算总耗时
+        const totalDuration = Date.now() - startTime;
+        const queryDuration = Date.now() - queryStartTime;
+        console.error(`\n✅ 任务生成完成！`);
+        console.error(`📝 Job ID: ${jobId}`);
+        console.error(`⏱️  结束时间: ${new Date().toLocaleString('zh-CN')}`);
+        console.error(`⏱️  查询耗时: ${formatDuration(queryDuration)} (${queryDuration}ms)`);
+        console.error(`⏱️  总计耗时: ${formatDuration(totalDuration)} (${totalDuration}ms)`);
+        console.error(`\n请启动消费者来处理任务：`);
+        console.error(`  npm run consumer -- --job-id ${jobId}\n`);
+        // 显示 Job 信息
+        const job = await queueManager.getJob(jobId);
+        if (job) {
+            console.error(`📊 任务统计:`);
+            console.error(`   总任务数: ${job.totalTasks}`);
+            console.error(`   待处理: ${job.totalTasks - job.completedTasks - job.failedTasks - job.skippedTasks}`);
+        }
+        await queueManager.close();
+    }
+    catch (error) {
+        const totalDuration = Date.now() - startTime;
+        console.error(`\n❌ 执行失败（耗时: ${formatDuration(totalDuration)}）:`, error);
+        await queueManager.close();
+        process.exit(1);
+    }
+}
+if (require.main === module) {
+    main().catch(error => {
+        console.error('未捕获的错误：', error);
+        process.exit(1);
+    });
+}

package/dist/cli/query-object.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=query-object.d.ts.map