@qwe8652591/abap-recursive-query 1.1.0

package/dist/recursive/recursiveObjectQuery.js

@@ -0,0 +1,1358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecursiveObjectQuery = void 0;
+const handleGetInclude_1 = require("../handlers/handleGetInclude");
+const handleGetClass_1 = require("../handlers/handleGetClass");
+const handleGetFunction_1 = require("../handlers/handleGetFunction");
+const handleGetProgram_1 = require("../handlers/handleGetProgram");
+const handleZObjectQuery_1 = require("../handlers/handleZObjectQuery");
+const handleZTableQuery_1 = require("../handlers/handleZTableQuery");
+const download_1 = require("../lib/download");
+const core_1 = require("@abaplint/core");
+const recursiveQueryConfig_1 = require("./recursiveQueryConfig");
+const path_1 = require("path");
+const fs_1 = require("fs");
+// 导入所有生成器模块 - 统一从 index.ts 导入
+const generate_1 = require("./generate");
+/**
+ * 异步任务队列管理器 - 修复死锁和任务丢失问题
+ * 优化版本：解决竞态条件、死锁和任务丢失问题
+ */
+class AsyncTaskQueue {
+    queue = [];
+    running = 0;
+    maxConcurrent;
+    taskResults = new Map(); // 改为存储Promise，支持多个调用者等待同一任务
+    processing = false;
+    processingRequests = 0; // 跟踪待处理的processQueue请求
+    waiters = []; // 用于通知等待者
+    constructor(maxConcurrent) {
+        this.maxConcurrent = Math.max(1, maxConcurrent); // 确保至少为1
+    }
+    async add(taskId, task) {
+        // 如果任务已存在，直接返回缓存的Promise（支持多个调用者等待同一任务）
+        if (this.taskResults.has(taskId)) {
+            return this.taskResults.get(taskId);
+        }
+        // 创建任务Promise并立即缓存
+        const taskPromise = new Promise((resolve, reject) => {
+            const wrappedTask = async () => {
+                try {
+                    this.running++;
+                    const result = await task();
+                    resolve(result);
+                    return result;
+                }
+                catch (error) {
+                    reject(error);
+                    throw error;
+                }
+                finally {
+                    this.running--;
+                    // 通知等待者
+                    this.notifyWaiters();
+                    // 任务完成后立即尝试处理队列中的下一个任务
+                    // 使用 process.nextTick 而不是 setImmediate，优先级更高
+                    process.nextTick(() => this.processQueue());
+                }
+            };
+            this.queue.push(wrappedTask);
+        });
+        // 缓存Promise，这样同一任务的多个调用者可以共享结果
+        this.taskResults.set(taskId, taskPromise);
+        // 立即尝试处理队列
+        this.processQueue();
+        return taskPromise;
+    }
+    processQueue() {
+        // 记录处理请求
+        this.processingRequests++;
+        // 避免重复处理，但记录请求数
+        if (this.processing) {
+            return;
+        }
+        this.processing = true;
+        // 使用异步处理避免阻塞
+        process.nextTick(() => {
+            try {
+                // 尽可能多地处理队列中的任务，直到达到并发限制
+                while (this.running < this.maxConcurrent && this.queue.length > 0) {
+                    const task = this.queue.shift();
+                    if (task) {
+                        // 启动任务但不等待
+                        task().catch(() => {
+                            // 错误已在wrappedTask中处理，这里只是防止未捕获的Promise rejection
+                        });
+                    }
+                }
+            }
+            finally {
+                this.processing = false;
+                this.processingRequests--;
+                // 如果还有待处理的请求或队列中还有任务，继续处理
+                if (this.processingRequests > 0 || (this.queue.length > 0 && this.running < this.maxConcurrent)) {
+                    this.processingRequests = 0; // 重置计数
+                    this.processQueue();
+                }
+            }
+        });
+    }
+    getQueueSize() {
+        return this.queue.length;
+    }
+    getRunningCount() {
+        return this.running;
+    }
+    /**
+     * 通知所有等待者
+     */
+    notifyWaiters() {
+        const waiters = [...this.waiters];
+        this.waiters = [];
+        waiters.forEach(waiter => waiter());
+    }
+    /**
+     * 等待所有任务完成（包括正在运行的和队列中的）
+     * 使用事件通知机制而不是轮询，避免死锁和CPU浪费
+     */
+    async waitForAll() {
+        while (this.queue.length > 0 || this.running > 0) {
+            // 如果还有任务，等待任务完成的通知
+            await new Promise((resolve) => {
+                // 检查是否已经完成
+                if (this.queue.length === 0 && this.running === 0) {
+                    resolve();
+                    return;
+                }
+                // 添加到等待者列表
+                this.waiters.push(resolve);
+                // 设置超时保护，避免永久等待
+                const timeout = setTimeout(() => {
+                    const index = this.waiters.indexOf(resolve);
+                    if (index !== -1) {
+                        this.waiters.splice(index, 1);
+                    }
+                    resolve();
+                }, 100); // 100ms超时
+                // 清理超时
+                const originalResolve = resolve;
+                this.waiters[this.waiters.length - 1] = () => {
+                    clearTimeout(timeout);
+                    originalResolve();
+                };
+            });
+            // 尝试处理队列中的剩余任务
+            if (this.queue.length > 0 && this.running < this.maxConcurrent) {
+                this.processQueue();
+            }
+        }
+        // 最终确保所有缓存的Promise都已完成
+        if (this.taskResults.size > 0) {
+            await Promise.allSettled(Array.from(this.taskResults.values()));
+        }
+    }
+    /**
+     * 清理已完成的任务缓存（可选，用于内存管理）
+     */
+    clearCache() {
+        this.taskResults.clear();
+    }
+}
+/**
+ * 递归对象查询器
+ * 用于查询ABAP对象及其引用的所有相关对象
+ */
+class RecursiveObjectQuery {
+    config;
+    result;
+    context;
+    taskQueue;
+    objectCache = new Map(); // 对象数据缓存
+    screenCache; // 屏幕缓存实例，每个查询进程独立
+    constructor(config = {}) {
+        this.config = { ...recursiveQueryConfig_1.defaultConfig, ...config };
+        // 始终合并默认过滤规则和用户配置的过滤规则
+        const userFilters = config.recursionFilters || {};
+        this.config.recursionFilters = {
+            // 合并 excludeNames：默认 + 用户配置
+            excludeNames: [
+                ...(recursiveQueryConfig_1.defaultFilters?.excludeNames || []),
+                ...(userFilters.excludeNames || [])
+            ],
+            // 合并 excludeNamePatterns：默认 + 用户配置
+            excludeNamePatterns: [
+                ...(recursiveQueryConfig_1.defaultFilters?.excludeNamePatterns || []),
+                ...(userFilters.excludeNamePatterns || [])
+            ]
+        };
+        const defaultCount = (recursiveQueryConfig_1.defaultFilters?.excludeNames?.length || 0) + (recursiveQueryConfig_1.defaultFilters?.excludeNamePatterns?.length || 0);
+        const userCount = (userFilters.excludeNames?.length || 0) + (userFilters.excludeNamePatterns?.length || 0);
+        console.error(`[过滤配置] 使用默认过滤规则 + 用户配置规则`);
+        console.error(`  - 默认规则: ${defaultCount} 个 (${recursiveQueryConfig_1.defaultFilters?.excludeNames?.length || 0} 精确 + ${recursiveQueryConfig_1.defaultFilters?.excludeNamePatterns?.length || 0} 模式)`);
+        console.error(`  - 用户规则: ${userCount} 个 (${userFilters.excludeNames?.length || 0} 精确 + ${userFilters.excludeNamePatterns?.length || 0} 模式)`);
+        console.error(`  - 总计规则: ${this.config.recursionFilters.excludeNames?.length || 0} 精确 + ${this.config.recursionFilters.excludeNamePatterns?.length || 0} 模式`);
+        this.result = {
+            originalObject: null,
+            allObjects: new Map(),
+            downloadedFiles: [],
+            filteredObjects: [],
+            statistics: {
+                totalObjects: 0,
+                totalClasses: 0,
+                totalFunctions: 0,
+                totalPrograms: 0,
+                totalIncludes: 0,
+                totalStructures: 0,
+                totalDomains: 0,
+                downloadedIncludes: 0,
+                downloadedStructures: 0,
+                downloadedDomains: 0,
+                maxDepthReached: 0,
+                circularReferences: 0
+            },
+            errors: [],
+            // 以下字段保留以保持接口兼容性，但在当前实现中未使用
+            totalObjects: 0,
+            downloadedObjects: 0,
+            failedObjects: 0,
+            skippedObjects: 0,
+            totalFiles: 0,
+            downloadedFilesCount: 0,
+            failedFiles: 0,
+            objectDetails: [],
+            startTime: new Date(),
+            endTime: new Date()
+        };
+        this.context = {
+            currentDepth: 0,
+            visitedPaths: new Set(),
+            dependencyGraph: new Map(),
+            config: this.config
+        };
+        this.taskQueue = new AsyncTaskQueue(this.config.concurrentRequestLimit);
+        this.screenCache = new generate_1.ScreenCache(); // 为每个查询实例创建独立的屏幕缓存
+        // 确保下载目录存在
+        if (this.config.downloadIncludes && !(0, fs_1.existsSync)(this.config.downloadRootPath)) {
+            (0, fs_1.mkdirSync)(this.config.downloadRootPath, { recursive: true });
+        }
+    }
+    /**
+     * 等待所有任务完成
+     */
+    async waitForAllTasks() {
+        console.error(`[等待完成] 等待所有任务完成，当前运行中: ${this.taskQueue.getRunningCount()}, 等待中: ${this.taskQueue.getQueueSize()}`);
+        // 使用队列的内置等待方法，确保所有任务都完成
+        await this.taskQueue.waitForAll();
+        console.error(`[等待完成] 所有任务已完成`);
+    }
+    /**
+     * 检查对象是否应该被过滤（不进行递归查询）
+     * @param objectType 对象类型
+     * @param objectName 对象名称
+     * @returns true表示应该过滤（不递归），false表示可以递归
+     */
+    shouldFilterRecursion(objectType, objectName) {
+        const filters = this.config.recursionFilters;
+        if (!filters) {
+            return false;
+        }
+        // 1. 检查是否在排除名称列表中（精确匹配）
+        if (filters.excludeNames && filters.excludeNames.length > 0) {
+            for (const name of filters.excludeNames) {
+                if (objectName.toUpperCase() === name.toUpperCase()) {
+                    const reason = `对象名称在排除列表中`;
+                    console.error(`[递归过滤] ${objectType}:${objectName} - ${reason}`);
+                    // 记录到结果中
+                    this.result.filteredObjects.push({
+                        objectType,
+                        objectName,
+                        reason,
+                        filterType: 'exact',
+                        filterRule: name,
+                        timestamp: new Date()
+                    });
+                    return true;
+                }
+            }
+        }
+        // 2. 检查对象名称是否匹配排除模式（支持通配符）
+        if (filters.excludeNamePatterns && filters.excludeNamePatterns.length > 0) {
+            for (const pattern of filters.excludeNamePatterns) {
+                if (this.matchPattern(objectName, pattern)) {
+                    const reason = `对象名称匹配排除模式 ${pattern}`;
+                    console.error(`[递归过滤] ${objectType}:${objectName} - ${reason}`);
+                    // 记录到结果中
+                    this.result.filteredObjects.push({
+                        objectType,
+                        objectName,
+                        reason,
+                        filterType: 'pattern',
+                        filterRule: pattern,
+                        timestamp: new Date()
+                    });
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * 模式匹配（支持通配符 * 和 ?）
+     * @param text 要匹配的文本
+     * @param pattern 模式字符串
+     * @returns 是否匹配
+     */
+    matchPattern(text, pattern) {
+        // 将通配符模式转换为正则表达式
+        // * 匹配任意字符（0个或多个）
+        // ? 匹配单个字符
+        const regexPattern = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&') // 转义特殊字符
+            .replace(/\*/g, '.*') // * 转换为 .*
+            .replace(/\?/g, '.'); // ? 转换为 .
+        const regex = new RegExp(`^${regexPattern}$`, 'i'); // 不区分大小写
+        return regex.test(text);
+    }
+    /**
+     * 执行递归查询（优化版本）
+     * @param objectType 对象类型
+     * @param objectName 对象名称
+     * @returns 查询结果
+     */
+    async execute(objectType, objectName) {
+        console.error(`[开始查询] 开始递归查询: ${objectType} - ${objectName}`);
+        console.error(`[配置信息] ${JSON.stringify(this.config, null, 2)}`);
+        const startTime = Date.now();
+        try {
+            // 启动主处理任务
+            await this.processObjectRecursively(objectType, objectName, 0);
+            // 等待所有并发任务完成
+            await this.waitForAllTasks();
+            // 生成所有缓存的屏幕XML文件（整合到一个文件中）
+            await (0, generate_1.finalizeScreenGeneration)(this.screenCache, this.config.downloadRootPath, this.result.downloadedFiles);
+        }
+        catch (error) {
+            const errorMessage = `递归查询失败: ${error instanceof Error ? error.message : String(error)}`;
+            this.result.errors.push(errorMessage);
+            console.error(errorMessage);
+        }
+        const endTime = Date.now();
+        const duration = endTime - startTime;
+        console.error(`[查询完成] 递归查询完成，耗时: ${duration}ms`);
+        console.error(`[统计信息] ${JSON.stringify(this.result.statistics, null, 2)}`);
+        console.error(`[缓存信息] 缓存命中: ${this.objectCache.size} 个对象`);
+        // 输出过滤对象统计
+        if (this.result.filteredObjects.length > 0) {
+            console.error(`\n[递归过滤] 共过滤 ${this.result.filteredObjects.length} 个对象，未进行递归查询`);
+            // 按过滤类型分组统计
+            const exactFiltered = this.result.filteredObjects.filter(obj => obj.filterType === 'exact');
+            const patternFiltered = this.result.filteredObjects.filter(obj => obj.filterType === 'pattern');
+            if (exactFiltered.length > 0) {
+                console.error(`  📌 精确匹配过滤: ${exactFiltered.length} 个`);
+            }
+            if (patternFiltered.length > 0) {
+                console.error(`  🔍 模式匹配过滤: ${patternFiltered.length} 个`);
+            }
+        }
+        // 输出下载失败的文件列表
+        const failedFiles = this.result.downloadedFiles.filter(file => !file.success);
+        if (failedFiles.length > 0) {
+            console.error(`\n[下载失败] 共有 ${failedFiles.length} 个文件下载失败:`);
+            failedFiles.forEach(file => {
+                console.error(`  ❌ ${file.objectType}/${file.objectName}.abap - ${file.error}`);
+            });
+        }
+        else {
+            console.error(`\n[下载成功] 所有文件下载成功，共 ${this.result.downloadedFiles.length} 个文件`);
+        }
+        return this.result;
+    }
+    /**
+     * 递归处理对象（优化版本）
+     * 采用并发队列 + 缓存机制，提高执行效率
+     * 修复死锁问题：
+     * 1. 避免在任务队列内部进行递归调用
+     * 2. 使用正确的循环引用检测机制
+     * 3. 分离查询和递归处理逻辑
+     */
+    async processObjectRecursively(objectType, objectName, depth) {
+        if (depth > this.config.maxRecursionDepth) {
+            console.error(`达到最大递归深度 ${this.config.maxRecursionDepth}，停止处理`);
+            return;
+        }
+        const objectKey = this.generateObjectKey(objectType, objectName);
+        // 检查对象缓存，避免重复处理
+        if (this.objectCache.has(objectKey)) {
+            console.error(`对象已缓存，跳过处理: ${objectKey}`);
+            return;
+        }
+        // 检查循环引用 - 修复：使用永久标记，不在finally中删除
+        if (this.context.visitedPaths.has(objectKey)) {
+            this.result.statistics.circularReferences++;
+            console.error(`检测到循环引用: ${objectKey}`);
+            return;
+        }
+        // 标记为已访问（永久标记，防止循环引用）
+        this.context.visitedPaths.add(objectKey);
+        // 先标记缓存，防止并发时重复处理
+        this.objectCache.set(objectKey, null);
+        try {
+            // 使用任务队列进行并发处理 - 只处理当前对象，不在队列内递归
+            await this.taskQueue.add(objectKey, async () => {
+                this.context.currentDepth = depth;
+                this.result.statistics.maxDepthReached = Math.max(this.result.statistics.maxDepthReached, depth);
+                console.error(`[并发处理] 开始处理对象: ${objectType} - ${objectName} (深度: ${depth})`);
+                console.error(`[队列状态] 运行中: ${this.taskQueue.getRunningCount()}, 等待中: ${this.taskQueue.getQueueSize()}`);
+                // 1. 查询对象引用内容（包含函数组信息）
+                const queryResult = await this.queryObjectReferences(objectType, objectName);
+                if (!queryResult.success || !queryResult.data) {
+                    console.error(`查询对象失败: ${objectType} - ${objectName}, 错误: ${queryResult.error}`);
+                    throw new Error(queryResult.error || '查询失败');
+                }
+                const objectData = queryResult.data;
+                // 更新缓存为实际数据
+                this.objectCache.set(objectKey, objectData);
+                // 设置原始对象（仅在第一次调用时）
+                if (depth === 0) {
+                    this.result.originalObject = objectData;
+                }
+                // 存储对象数据
+                this.result.allObjects.set(objectKey, objectData);
+                this.result.statistics.totalObjects++;
+                console.error(`[并发处理] 完成查询对象: ${objectType} - ${objectName}`);
+                return objectData;
+            });
+            // 2. 在队列外部处理递归调用，避免嵌套死锁
+            const objectData = this.objectCache.get(objectKey);
+            if (!objectData) {
+                return; // 查询失败，已记录错误
+            }
+            // 智能请求间隔控制：只在队列压力过大时添加延迟
+            const queueSize = this.taskQueue.getQueueSize();
+            const runningCount = this.taskQueue.getRunningCount();
+            const totalPending = queueSize + runningCount;
+            if (this.config.requestInterval > 0 && totalPending > this.config.concurrentRequestLimit * 2) {
+                console.error(`[智能延迟] 队列积压严重（等待:${queueSize}, 运行中:${runningCount}），添加 ${this.config.requestInterval}ms 延迟`);
+                await this.delay(this.config.requestInterval);
+            }
+            // 3. 收集需要递归处理的子对象
+            const childObjects = [];
+            // 收集类引用
+            if (this.config.recursiveClasses && objectData.ET_REFCLASS && Array.isArray(objectData.ET_REFCLASS)) {
+                if (depth < this.config.maxRecursionDepth) {
+                    this.result.statistics.totalClasses += objectData.ET_REFCLASS.length;
+                    console.error(`[递归检查] 当前深度 ${depth}，最大深度 ${this.config.maxRecursionDepth}，准备递归处理 ${objectData.ET_REFCLASS.length} 个类`);
+                    for (const cls of objectData.ET_REFCLASS) {
+                        if (cls.CLSNAME) {
+                            childObjects.push({ type: 'CLASS', name: cls.CLSNAME });
+                        }
+                    }
+                }
+                else {
+                    console.error(`[递归限制] 已达到最大递归深度 ${this.config.maxRecursionDepth}，跳过类递归处理`);
+                }
+            }
+            // 收集函数引用
+            if (this.config.recursiveFunctions && objectData.ET_REFFUNCTION && Array.isArray(objectData.ET_REFFUNCTION)) {
+                if (depth < this.config.maxRecursionDepth) {
+                    this.result.statistics.totalFunctions += objectData.ET_REFFUNCTION.length;
+                    console.error(`[递归检查] 当前深度 ${depth}，最大深度 ${this.config.maxRecursionDepth}，准备递归处理 ${objectData.ET_REFFUNCTION.length} 个函数`);
+                    for (const func of objectData.ET_REFFUNCTION) {
+                        if (func.FUNCTIONNAME) {
+                            childObjects.push({ type: 'FUNCTION', name: func.FUNCTIONNAME });
+                        }
+                    }
+                }
+                else {
+                    console.error(`[递归限制] 已达到最大递归深度 ${this.config.maxRecursionDepth}，跳过函数递归处理`);
+                }
+            }
+            // 收集程序引用
+            if (this.config.recursivePrograms && objectData.ET_REFPROGRAM && Array.isArray(objectData.ET_REFPROGRAM)) {
+                if (depth < this.config.maxRecursionDepth) {
+                    this.result.statistics.totalPrograms += objectData.ET_REFPROGRAM.length;
+                    console.error(`[递归检查] 当前深度 ${depth}，最大深度 ${this.config.maxRecursionDepth}，准备递归处理 ${objectData.ET_REFPROGRAM.length} 个程序`);
+                    for (const prog of objectData.ET_REFPROGRAM) {
+                        if (prog.PROGNAME) {
+                            childObjects.push({ type: 'PROGRAM', name: prog.PROGNAME });
+                        }
+                    }
+                }
+                else {
+                    console.error(`[递归限制] 已达到最大递归深度 ${this.config.maxRecursionDepth}，跳过程序递归处理`);
+                }
+            }
+            // 4. 在队列外部递归处理子对象，避免死锁
+            if (childObjects.length > 0) {
+                console.error(`[批量递归] 准备递归处理 ${childObjects.length} 个子对象 (深度: ${depth + 1})`);
+                // 应用过滤条件，排除不需要递归的对象
+                const filteredChildObjects = childObjects.filter(child => {
+                    const shouldFilter = this.shouldFilterRecursion(child.type, child.name);
+                    if (shouldFilter) {
+                        console.error(`[递归过滤] 跳过子对象 ${child.type}:${child.name} 的递归处理`);
+                    }
+                    return !shouldFilter;
+                });
+                if (filteredChildObjects.length > 0) {
+                    console.error(`[批量递归] 经过过滤后剩余 ${filteredChildObjects.length} 个子对象需要递归处理`);
+                    // 使用 Promise.allSettled 并发处理所有子对象
+                    // 这里的递归调用会再次进入任务队列，由队列控制并发
+                    const childPromises = filteredChildObjects.map(child => this.processObjectRecursively(child.type, child.name, depth + 1)
+                        .catch(error => {
+                        const errorMessage = `递归处理 ${child.type}:${child.name} 失败: ${error instanceof Error ? error.message : String(error)}`;
+                        console.error(errorMessage);
+                    }));
+                    await Promise.allSettled(childPromises);
+                    console.error(`[批量递归] 完成递归处理 ${filteredChildObjects.length} 个子对象`);
+                }
+                else if (childObjects.length > 0) {
+                    console.error(`[批量递归] 所有 ${childObjects.length} 个子对象都被过滤，不进行递归处理`);
+                }
+            }
+            console.error(`[并发处理] 完全完成对象处理: ${objectType} - ${objectName}`);
+        }
+        catch (error) {
+            const errorMessage = `处理对象 ${objectKey} 失败: ${error instanceof Error ? error.message : String(error)}`;
+            this.result.errors.push(errorMessage);
+            console.error(errorMessage);
+            // 不删除 visitedPaths，保持循环引用保护
+            // 但清理无效的缓存
+            if (!this.objectCache.get(objectKey)) {
+                this.objectCache.delete(objectKey);
+            }
+        }
+    }
+    /**
+     * 处理函数组
+     * 当处理函数时，提取函数组信息并生成函数组文件
+     */
+    async processFunctionGroup(functions, objectName) {
+        if (!functions || functions.length === 0) {
+            return;
+        }
+        // 提取函数组名称
+        const functionGroup = functions[0]?.FUNCTIONGROUP;
+        if (!functionGroup) {
+            console.error(`函数 ${objectName} 没有函数组信息，跳过函数组文件生成`);
+            return;
+        }
+        console.error(`处理函数组: ${functionGroup}，包含 ${functions.length} 个函数`);
+        try {
+            // 准备函数列表数据
+            const functionList = functions.map(func => ({
+                FUNCNAME: func.FUNCTIONNAME || objectName,
+                FMODE: func.FMODE || '',
+                STEXT: func.SHORT_TEXT || func.STEXT || '',
+                REMOTE_CALL: func.REMOTE_CALL || ''
+            }));
+            // 使用 functionGroupGenerator 生成函数组文件
+            await (0, generate_1.generateFunctionGroupFiles)(functionGroup, functionList, this.config.downloadRootPath, this.result.downloadedFiles);
+            console.error(`函数组 ${functionGroup} 处理完成`);
+        }
+        catch (error) {
+            const errorMessage = `处理函数组 ${functionGroup} 失败: ${error instanceof Error ? error.message : String(error)}`;
+            this.result.errors.push(errorMessage);
+            console.error(errorMessage);
+        }
+    }
+    /**
+     * 处理包含文件
+     */
+    async processIncludes(includes) {
+        this.result.statistics.totalIncludes += includes.length;
+        for (const include of includes) {
+            if (!include.INCLUDENAME)
+                continue;
+            const includeName = include.INCLUDENAME;
+            console.error(`处理包含文件: ${includeName}`);
+            // 下载包含文件（如果配置了）
+            if (this.config.downloadIncludes) {
+                await this.downloadIncludeWithTypeDetection(includeName);
+            }
+        }
+    }
+    /**
+     * 下载 include 文件并根据内容自动检测类型，添加符合 abaplint 规范的后缀
+     */
+    async downloadIncludeWithTypeDetection(includeName) {
+        const expectedFilePath = this.generateFilePath(includeName, 'INCLUDE');
+        try {
+            // 1. 获取 include 文件内容
+            const includeResult = await (0, handleGetInclude_1.handleGetInclude)({ include_name: includeName });
+            // 统一处理错误情况
+            if (!includeResult) {
+                throw new Error(`获取包含文件 ${includeName} 失败: 无响应数据`);
+            }
+            if (includeResult.isError) {
+                const errorText = Array.isArray(includeResult.content) && includeResult.content.length > 0
+                    ? includeResult.content[0].text || '未知错误'
+                    : '未知错误';
+                throw new Error(`获取包含文件 ${includeName} 失败: ${errorText}`);
+            }
+            if (!includeResult.content) {
+                throw new Error(`获取包含文件 ${includeName} 失败: 无有效内容返回`);
+            }
+            const content = Array.isArray(includeResult.content)
+                ? includeResult.content.map(item => item.text || '').join('\n')
+                : String(includeResult.content || '');
+            // 2. 分析内容类型
+            const includeType = this.detectIncludeType(content, includeName);
+            console.error(`检测到包含文件 ${includeName} 的类型: ${includeType}`);
+            // 3. 根据类型生成文件路径
+            const finalFilePath = this.generateIncludeFilePath(includeName, includeType);
+            // 确保目录存在
+            const dirPath = (0, path_1.dirname)(finalFilePath);
+            if (!(0, fs_1.existsSync)(dirPath)) {
+                (0, fs_1.mkdirSync)(dirPath, { recursive: true });
+            }
+            // 4. 下载文件
+            const downloadResult = await (0, download_1.downloadFile)(content, finalFilePath, 'abap');
+            this.result.downloadedFiles.push({
+                objectName: includeName,
+                objectType: 'INCLUDE',
+                filePath: finalFilePath,
+                success: downloadResult.success,
+                error: downloadResult.success ? undefined : downloadResult.message,
+                metadata: {
+                    detectedType: includeType
+                }
+            });
+            if (downloadResult.success) {
+                this.result.statistics.downloadedIncludes++;
+                console.error(`包含文件下载成功: ${includeName} [${includeType}] -> ${downloadResult.filePath}`);
+            }
+            else {
+                console.error(`包含文件下载失败: ${includeName} - ${downloadResult.message}`);
+            }
+        }
+        catch (error) {
+            this.handleDownloadError(includeName, 'INCLUDE', expectedFilePath, error);
+        }
+    }
+    /**
+     * 使用 abaplint 进行精确的语法分析来检测 include 文件类型
+     * 这是最准确的方法，因为它真正解析了 ABAP 语法
+     */
+    detectIncludeType(content, fileName) {
+        console.error(`[类型检测] 使用 abaplint 分析文件: ${fileName}`);
+        try {
+            // 创建临时 Registry 和文件
+            const tempRegistry = new core_1.Registry(core_1.Config.getDefault());
+            // abaplint 需要 .prog.abap 或类似后缀才能识别
+            const tempFileName = `${fileName}.prog.abap`;
+            const memFile = new core_1.MemoryFile(tempFileName, content);
+            tempRegistry.addFile(memFile);
+            tempRegistry.parse();
+            // 获取对象（abaplint 会尝试识别文件类型）
+            const obj = tempRegistry.findObjectForFile(memFile);
+            console.error(`[abaplint] 对象类型: ${obj ? obj.getType() : 'null'}`);
+            if (obj && obj instanceof core_1.ABAPObject) {
+                const abapFiles = obj.getABAPFiles();
+                console.error(`[abaplint] ABAP 文件数: ${abapFiles.length}`);
+                if (abapFiles.length > 0) {
+                    const file = abapFiles[0];
+                    const fileInfo = file.getInfo();
+                    // 检查是否包含测试类
+                    const testClasses = fileInfo.listClassDefinitions().filter(cls => cls.isForTesting);
+                    if (testClasses.length > 0) {
+                        console.error(`[abaplint] 检测到 ${testClasses.length} 个测试类 -> TESTCLASSES`);
+                        return 'TESTCLASSES';
+                    }
+                    // 检查类定义和实现
+                    const classDefinitions = fileInfo.listClassDefinitions();
+                    const classImplementations = fileInfo.listClassImplementations();
+                    console.error(`[abaplint] 类定义: ${classDefinitions.length}, 类实现: ${classImplementations.length}`);
+                    if (classDefinitions.length > 0 && classImplementations.length === 0) {
+                        console.error(`[abaplint] 检测为: LOCALS_DEF`);
+                        return 'LOCALS_DEF';
+                    }
+                    if (classImplementations.length > 0) {
+                        console.error(`[abaplint] 检测为: LOCALS_IMP`);
+                        return 'LOCALS_IMP';
+                    }
+                    // 检查接口定义
+                    const interfaces = fileInfo.listInterfaceDefinitions();
+                    if (interfaces.length > 0) {
+                        console.error(`[abaplint] 检测到 ${interfaces.length} 个接口定义 -> LOCALS_DEF`);
+                        return 'LOCALS_DEF'; // 接口定义也使用 locals_def
+                    }
+                    // 检查 FORM 子例程
+                    const forms = fileInfo.listFormDefinitions();
+                    console.error(`[abaplint] FORM 子例程数: ${forms.length}`);
+                    if (forms.length >= 1) {
+                        console.error(`[abaplint] 检测到 ${forms.length} 个子例程 -> SUBROUTINES`);
+                        return 'SUBROUTINES';
+                    }
+                }
+            }
+            else {
+                console.error(`[abaplint] 无法识别为 ABAPObject`);
+            }
+            console.error(`[abaplint] 未检测到特殊类型 -> STANDARD`);
+            return 'STANDARD';
+        }
+        catch (error) {
+            console.error(`[abaplint] 解析失败: ${error instanceof Error ? error.message : String(error)}`);
+            if (error instanceof Error && error.stack) {
+                console.error(`[abaplint] 堆栈: ${error.stack.substring(0, 500)}`);
+            }
+            // 解析失败时返回标准类型
+            return 'STANDARD';
+        }
+    }
+    /**
+     * 根据 include 类型生成符合 abaplint 规范的文件路径
+     */
+    generateIncludeFilePath(includeName, includeType) {
+        const sanitizedName = includeName
+            .replace(/[/\\]/g, '_')
+            .replace(/[<>]/g, '#')
+            .replace(/[^a-zA-Z0-9_#]/g, '_');
+        let extension;
+        switch (includeType) {
+            case 'LOCALS_DEF':
+                extension = 'clas.locals_def.abap';
+                break;
+            case 'LOCALS_IMP':
+                extension = 'clas.locals_imp.abap';
+                break;
+            case 'TESTCLASSES':
+                extension = 'clas.testclasses.abap';
+                break;
+            case 'MACROS':
+                extension = 'clas.macros.abap';
+                break;
+            case 'SCREENS':
+                extension = 'prog.screens.abap';
+                break;
+            case 'SUBROUTINES':
+                extension = 'prog.subs.abap';
+                break;
+            case 'STANDARD':
+            default:
+                extension = 'prog.abap';
+                break;
+        }
+        return (0, path_1.join)(this.config.downloadRootPath, 'includes', `${sanitizedName}.${extension}`);
+    }
+    /**
+     * 处理文本元素
+     * 按照abapGit协议，文本元素应该单独导出为XML文件
+     */
+    async processTextElements(textElements, objectName, objectType) {
+        if (!textElements || textElements.length === 0) {
+            return;
+        }
+        console.error(`处理${objectType} ${objectName} 的文本元素，共 ${textElements.length} 个`);
+        try {
+            // 使用textElementGenerator生成XML文件
+            await (0, generate_1.generateTextElementsXml)(textElements, objectName, objectType, this.config.downloadRootPath, this.result.downloadedFiles);
+        }
+        catch (error) {
+            const errorMessage = `处理${objectType} ${objectName} 的文本元素失败: ${error instanceof Error ? error.message : String(error)}`;
+            this.result.errors.push(errorMessage);
+            console.error(errorMessage);
+        }
+    }
+    /**
+     * 处理消息
+     * 按照abapGit协议，消息应该使用MSAG XML格式单独导出
+     */
+    async processMessages(messages, objectName, objectType) {
+        if (!messages || messages.length === 0) {
+            return;
+        }
+        console.error(`处理${objectType} ${objectName} 的消息，共 ${messages.length} 个`);
+        try {
+            // 使用messageGenerator生成XML文件
+            await (0, generate_1.generateMessageClassXml)(messages, objectName, this.config.downloadRootPath, this.result.downloadedFiles);
+        }
+        catch (error) {
+            const errorMessage = `处理${objectType} ${objectName} 的消息失败: ${error instanceof Error ? error.message : String(error)}`;
+            this.result.errors.push(errorMessage);
+            console.error(errorMessage);
+        }
+    }
+    /**
+     * 处理GUI标题
+     */
+    async processGuiTitles(guiTitles, objectName, objectType) {
+        if (!guiTitles || guiTitles.length === 0) {
+            return;
+        }
+        console.error(`处理${objectType} ${objectName} 的GUI标题，共 ${guiTitles.length} 个`);
+        try {
+            // 导出到JSON文件 - 下载到guiTitles目录下
+            const baseDir = (0, path_1.join)(this.config.downloadRootPath, 'guiTitles');
+            if (!(0, fs_1.existsSync)(baseDir)) {
+                (0, fs_1.mkdirSync)(baseDir, { recursive: true });
+            }
+            const safeObjectName = objectName.replace(/[/\\]/g, '_');
+            const guiTitlesPath = (0, path_1.join)(baseDir, `${safeObjectName}_${objectType.toLowerCase()}_guititles.json`);
+            (0, fs_1.writeFileSync)(guiTitlesPath, JSON.stringify(guiTitles, null, 2), 'utf-8');
+            console.error(`导出${objectType} ${objectName} 的GUI标题到: ${guiTitlesPath}`);
+            // 记录下载统计
+            this.result.downloadedFiles.push({
+                objectName: objectName,
+                objectType: 'GUI_TITLE',
+                filePath: guiTitlesPath,
+                success: true,
+                metadata: {
+                    titleCount: guiTitles.length,
+                    exportType: 'separate',
+                    objectType: objectType
+                }
+            });
+        }
+        catch (error) {
+            const errorMessage = `处理${objectType} ${objectName} 的GUI标题失败: ${error instanceof Error ? error.message : String(error)}`;
+            this.result.errors.push(errorMessage);
+            console.error(errorMessage);
+        }
+    }
+    /**
+     * 处理结构体
+     */
+    async processStructures(structures) {
+        this.result.statistics.totalStructures += structures.length;
+        if (!this.config.downloadStructures) {
+            return;
+        }
+        for (const structure of structures) {
+            if (!structure.TABLENAME)
+                continue;
+            await this.processSingleStructure(structure);
+        }
+    }
+    /**
+     * 处理单个结构体
+     */
+    async processSingleStructure(structure) {
+        const structureName = structure.TABLENAME;
+        console.error(`处理结构体: ${structureName}`);
+        const expectedFilePath = this.generateFilePath(structureName, 'STRUCTURE');
+        try {
+            // 使用structureGenerator生成结构体内容
+            const structureContent = (0, generate_1.generateStructureContent)(structure);
+            await this.downloadStructureFile(structureContent, expectedFilePath, structureName);
+            // 处理结构体字段中的domain定义
+            if (structure.ISTRUCTURE && structure.ISTRUCTURE.length > 0) {
+                await this.processStructureDomains(structure.ISTRUCTURE, structureName);
+            }
+            // 如果是透明表(TRANSP)，则调用Z_TABLE_QUERY获取完整表结构信息
+            if (structure.TABLECLASS === 'TRANSP') {
+                console.error(`检测到透明表 ${structureName}，开始获取完整表结构信息`);
+                await this.processTransparentTable(structureName);
+            }
+        }
+        catch (error) {
+            this.handleDownloadError(structureName, 'STRUCTURE', expectedFilePath, error);
+        }
+    }
+    /**
+     * 处理透明表，获取并保存完整表结构信息
+     */
+    async processTransparentTable(tableName) {
+        try {
+            const response = await (0, handleZTableQuery_1.handleZTableQuery)({ name: tableName });
+            if (response && response.content && response.content.length > 0) {
+                const tableData = response.content[0].text;
+                // 解析JSON数据
+                let parsedData;
+                try {
+                    parsedData = tableData;
+                }
+                catch (parseError) {
+                    console.error(`解析表结构数据失败: ${tableName}, 错误: ${parseError}`);
+                    return;
+                }
+                // 转换为 TableData 格式（单表结构：表信息 + 字段列表 + 索引列表）
+                const tableInfo = parsedData.GT_TABLES && parsedData.GT_TABLES.length > 0
+                    ? parsedData.GT_TABLES[0]
+                    : { TABNAME: tableName };
+                const finalTableData = {
+                    IDX: tableInfo.IDX,
+                    TABNAME: tableInfo.TABNAME,
+                    TABCLASS: tableInfo.TABCLASS,
+                    DDTEXT_ZH: tableInfo.DDTEXT_ZH,
+                    DDTEXT_EN: tableInfo.DDTEXT_EN,
+                    GT_FIELDS: parsedData.GT_FIELDS || [],
+                    GT_INDEXS: parsedData.GT_INDEXS || []
+                };
+                // 生成文件路径：downloadRootPath/tables/表名.json
+                const tablesDir = (0, path_1.join)(this.config.downloadRootPath, 'tables');
+                if (!(0, fs_1.existsSync)(tablesDir)) {
+                    (0, fs_1.mkdirSync)(tablesDir, { recursive: true });
+                }
+                const sanitizedName = tableName
+                    .replace(/[/\\]/g, '_')
+                    .replace(/[<>]/g, '#')
+                    .replace(/[^a-zA-Z0-9_#]/g, '_');
+                const tableFilePath = (0, path_1.join)(tablesDir, `${sanitizedName}.json`);
+                // 保存JSON文件
+                (0, fs_1.writeFileSync)(tableFilePath, JSON.stringify(finalTableData, null, 2), 'utf-8');
+                console.error(`透明表结构已保存: ${tableFilePath}`);
+                // 记录下载结果
+                this.result.downloadedFiles.push({
+                    objectName: tableName,
+                    objectType: 'TABLE',
+                    filePath: tableFilePath,
+                    success: true
+                });
+            }
+            else {
+                console.error(`获取透明表结构失败: ${tableName}, 无有效数据返回`);
+            }
+        }
+        catch (error) {
+            console.error(`处理透明表失败: ${tableName}, 错误: ${error instanceof Error ? error.message : String(error)}`);
+            // 记录错误
+            this.result.downloadedFiles.push({
+                objectName: tableName,
+                objectType: 'TABLE',
+                filePath: (0, path_1.join)(this.config.downloadRootPath, 'tables', `${tableName}.json`),
+                success: false,
+                error: error instanceof Error ? error.message : String(error)
+            });
+        }
+    }
+    /**
+     * 处理结构体字段中的domain定义
+     */
+    async processStructureDomains(fields, structureName) {
+        const domainsMap = new Map();
+        // 收集所有需要处理的domain及其数据
+        for (const field of fields) {
+            if (field.IDOMAINS && field.IDOMAINS.length > 0) {
+                for (const domain of field.IDOMAINS) {
+                    if (domain.DOMNAME) {
+                        if (!domainsMap.has(domain.DOMNAME)) {
+                            domainsMap.set(domain.DOMNAME, []);
+                        }
+                        domainsMap.get(domain.DOMNAME).push(domain);
+                    }
+                }
+            }
+        }
+        if (domainsMap.size === 0) {
+            return;
+        }
+        console.error(`结构体 ${structureName} 包含 ${domainsMap.size} 个domain定义，开始导出...`);
+        // 更新统计信息
+        this.result.statistics.totalDomains += domainsMap.size;
+        // 确保domain目录存在
+        const domainsDir = (0, path_1.join)(this.config.downloadRootPath, 'structures', 'domains');
+        if (!(0, fs_1.existsSync)(domainsDir)) {
+            (0, fs_1.mkdirSync)(domainsDir, { recursive: true });
+        }
+        // 处理每个domain
+        for (const [domainName, domainData] of domainsMap) {
+            await this.processSingleDomain(domainName, structureName, domainData);
+        }
+    }
+    /**
+     * 处理单个domain定义
+     */
+    async processSingleDomain(domainName, structureName, domainData) {
+        try {
+            console.error(`处理domain: ${domainName} (来自结构体 ${structureName})`);
+            // 使用domainGenerator生成domain文件内容
+            const domainContent = (0, generate_1.generateDomainContent)(domainName, domainData);
+            // 获取domain文件路径
+            const domainFilePath = this.generateFilePath(domainName, 'DOMAIN');
+            // 下载domain文件
+            await this.downloadDomainFile(domainContent, domainFilePath, domainName, structureName);
+        }
+        catch (error) {
+            const errorMessage = `处理domain ${domainName} 失败: ${error instanceof Error ? error.message : String(error)}`;
+            this.result.errors.push(errorMessage);
+            console.error(errorMessage);
+        }
+    }
+    /**
+     * 统一的文件路径生成器 - 根据对象类型和名称生成标准文件路径
+     * 支持多种ABAP对象类型：DOMAIN, STRUCTURE, CLASS, FUNCTION, PROGRAM, INCLUDE
+     */
+    generateFilePath(objectName, objectType, extension) {
+        const sanitizedName = objectName
+            .replace(/[/\\]/g, '_') // 路径分隔符替换为下划线
+            .replace(/[<>]/g, '#') // 命名空间尖括号替换为#
+            .replace(/[^a-zA-Z0-9_#]/g, '_'); // 其他特殊字符替换为下划线
+        const defaultExtension = this.getDefaultExtension(objectType);
+        const fileExtension = extension || defaultExtension;
+        const directory = this.getObjectDirectory(objectType);
+        return (0, path_1.join)(this.config.downloadRootPath, directory, `${sanitizedName}.${fileExtension}`);
+    }
+    /**
+     * 获取ABAP对象类型的默认文件扩展名
+     */
+    getDefaultExtension(objectType) {
+        const extensionMap = {
+            'DOMAIN': 'dom.abap',
+            'STRUCTURE': 'tabl.abap',
+            'CLASS': 'clas.abap',
+            'FUNCTION': 'func.abap',
+            'PROGRAM': 'prog.abap',
+            'INCLUDE': 'abap'
+        };
+        return extensionMap[objectType.toUpperCase()] || 'abap';
+    }
+    /**
+     * 获取ABAP对象类型的标准目录名
+     */
+    getObjectDirectory(objectType) {
+        const directoryMap = {
+            'DOMAIN': 'structures/domains',
+            'STRUCTURE': 'structures',
+            'CLASS': 'classes',
+            'FUNCTION': 'functions',
+            'PROGRAM': 'programs',
+            'INCLUDE': 'includes'
+        };
+        return directoryMap[objectType.toUpperCase()] || 'others';
+    }
+    /**
+     * 下载domain文件
+     */
+    async downloadDomainFile(content, filePath, domainName, structureName) {
+        const dirPath = (0, path_1.dirname)(filePath);
+        if (!(0, fs_1.existsSync)(dirPath)) {
+            (0, fs_1.mkdirSync)(dirPath, { recursive: true });
+        }
+        const downloadResult = await (0, download_1.downloadFile)(content, filePath, 'abap');
+        this.result.downloadedFiles.push({
+            objectName: domainName,
+            objectType: 'DOMAIN',
+            filePath: filePath,
+            success: downloadResult.success,
+            error: downloadResult.success ? undefined : downloadResult.message
+        });
+        if (downloadResult.success) {
+            this.result.statistics.downloadedDomains++;
+            console.error(`domain生成成功: ${domainName} (来自结构体 ${structureName}) -> ${downloadResult.filePath}`);
+        }
+        else {
+            console.error(`domain生成失败: ${domainName} (来自结构体 ${structureName}) - ${downloadResult.message}`);
+        }
+    }
+    /**
+     * 下载结构文件
+     */
+    async downloadStructureFile(content, filePath, structureName) {
+        const dirPath = (0, path_1.dirname)(filePath);
+        if (!(0, fs_1.existsSync)(dirPath)) {
+            (0, fs_1.mkdirSync)(dirPath, { recursive: true });
+        }
+        const downloadResult = await (0, download_1.downloadFile)(content, filePath, 'abap');
+        this.result.downloadedFiles.push({
+            objectName: structureName,
+            objectType: 'STRUCTURE',
+            filePath: filePath,
+            success: downloadResult.success,
+            error: downloadResult.success ? undefined : downloadResult.message
+        });
+        if (downloadResult.success) {
+            this.result.statistics.downloadedStructures++;
+            console.error(`结构体生成成功: ${structureName} -> ${downloadResult.filePath}`);
+        }
+        else {
+            console.error(`结构体生成失败: ${structureName} - ${downloadResult.message}`);
+        }
+    }
+    /**
+     * 通用下载错误处理方法
+     */
+    handleDownloadError(objectName, objectType, expectedFilePath, error) {
+        const errorMessage = `下载${objectType} ${objectName} 失败: ${error instanceof Error ? error.message : String(error)}`;
+        this.result.errors.push(errorMessage);
+        console.error(errorMessage);
+        this.result.downloadedFiles.push({
+            objectName: objectName,
+            objectType: objectType,
+            filePath: expectedFilePath,
+            success: false,
+            error: errorMessage
+        });
+    }
+    /**
+     * 从对象数据中提取函数组信息
+     */
+    extractFunctionGroup(objectData) {
+        console.error(objectData.ET_FUNCTION);
+        if (objectData.ET_FUNCTION && Array.isArray(objectData.ET_FUNCTION) && objectData.ET_FUNCTION.length > 0) {
+            const func = objectData.ET_FUNCTION[0];
+            return func.FUNCTIONGROUP ?? null;
+        }
+        else {
+            return null;
+        }
+    }
+    /**
+     * 使用已有的对象数据下载对象源代码（包含正确的函数组信息）
+     */
+    async downloadObjectSourceWithData(objectType, objectName, objectData) {
+        // 使用统一的文件路径生成器
+        const expectedFilePath = this.generateFilePath(objectName, objectType);
+        try {
+            console.error(`使用对象数据下载源代码: ${objectType} - ${objectName}`);
+            let sourceResult;
+            let functionGroup = null;
+            switch (objectType.toUpperCase()) {
+                case 'CLASS':
+                    sourceResult = await (0, handleGetClass_1.handleGetClass)({ class_name: objectName });
+                    break;
+                case 'FUNCTION':
+                    let functionGroup = this.extractFunctionGroup(objectData);
+                    console.error(functionGroup);
+                    // 如果无法从对象数据中提取函数组，尝试使用函数名前缀作为函数组
+                    if (!functionGroup) {
+                        functionGroup = objectName.split('_')[0] || objectName;
+                        console.error(`无法从对象数据中提取函数组，使用函数名前缀作为函数组: ${functionGroup}`);
+                    }
+                    else {
+                        console.error(`从对象数据中提取到函数组: ${functionGroup}`);
+                    }
+                    // 使用正确的函数组和函数名调用handleGetFunction
+                    sourceResult = await (0, handleGetFunction_1.handleGetFunction)({
+                        function_name: objectName,
+                        function_group: functionGroup
+                    });
+                    break;
+                case 'PROGRAM':
+                    sourceResult = await (0, handleGetProgram_1.handleGetProgram)({ program_name: objectName });
+                    break;
+                default:
+                    console.error(`不支持的下载对象类型: ${objectType}`);
+                    return { success: true }; // 不支持的类型不视为错误
+            }
+            // handlers 统一返回 return_response 格式，需要检查错误和提取内容
+            if (!sourceResult) {
+                throw new Error(`对象源代码获取失败: ${objectType} - ${objectName} - 无响应数据`);
+            }
+            // 检查是否是错误响应
+            if (sourceResult.isError) {
+                const errorText = Array.isArray(sourceResult.content) && sourceResult.content.length > 0
+                    ? sourceResult.content[0].text || '未知错误'
+                    : '未知错误';
+                throw new Error(`对象源代码获取失败: ${objectType} - ${objectName} - ${errorText}`);
+            }
+            // 检查是否有有效内容
+            if (!sourceResult.content || !Array.isArray(sourceResult.content) || sourceResult.content.length === 0) {
+                throw new Error(`对象源代码为空: ${objectType} - ${objectName}`);
+            }
+            // 从 return_response 格式中提取源代码
+            const sourceContent = sourceResult.content.map((item) => item.text || '').join('\n');
+            // 确保目录存在 - 直接使用expectedFilePath的目录，保持与generateFilePath一致
+            const dirPath = (0, path_1.dirname)(expectedFilePath);
+            if (!(0, fs_1.existsSync)(dirPath)) {
+                (0, fs_1.mkdirSync)(dirPath, { recursive: true });
+            }
+            // 直接使用expectedFilePath作为文件路径，避免路径不一致问题
+            const filePath = expectedFilePath;
+            const downloadResult = await (0, download_1.downloadFile)(sourceContent, filePath, 'abap');
+            this.result.downloadedFiles.push({
+                objectName: objectName,
+                objectType: objectType,
+                filePath: expectedFilePath,
+                success: downloadResult.success,
+                error: downloadResult.success ? undefined : downloadResult.message
+            });
+            if (downloadResult.success) {
+                console.error(`对象源代码下载成功: ${objectType} - ${objectName} -> ${downloadResult.filePath}`);
+                return { success: true };
+            }
+            else {
+                console.error(`对象源代码下载失败: ${objectType} - ${objectName} - ${downloadResult.message}`);
+                return { success: false, error: downloadResult.message };
+            }
+        }
+        catch (error) {
+            return { success: false, error: `下载对象源代码失败: ${objectType} - ${objectName} - ${error instanceof Error ? error.message : String(error)}` };
+        }
+    }
+    /**
+     * 查询对象引用内容（包含下载源代码）
+     * 现在包含下载逻辑，因为需要函数组信息来正确下载函数源代码
+     */
+    async queryObjectReferences(objectType, objectName) {
+        try {
+            console.error(`查询对象引用内容: ${objectType} - ${objectName}`);
+            const result = await (0, handleZObjectQuery_1.handleZObjectQuery)({
+                query_type: objectType,
+                query_name: objectName
+            });
+            // 成功: { isError: false, content: [{ type: 'text', text: data }] }
+            // 失败: { isError: true, content: [{ type: 'text', text: 'Error: ...' }] }
+            // 检查是否是错误响应
+            if (result && typeof result === 'object' && 'isError' in result && result.isError) {
+                const errorText = Array.isArray(result.content) && result.content.length > 0
+                    ? result.content[0].text || '未知错误'
+                    : '未知错误';
+                throw new Error(`查询对象失败: ${objectType} - ${objectName}, ${errorText}`);
+            }
+            // 从 return_response 格式中提取数据
+            let actualData;
+            if (result && typeof result === 'object' && 'content' in result && Array.isArray(result.content)) {
+                if (result.content.length > 0 && result.content[0].text) {
+                    actualData = result.content[0].text;
+                }
+            }
+            if (actualData !== undefined && actualData !== null) {
+                // 如果配置了下载包含文件，现在下载源代码（此时已有函数组信息）
+                const downloadResult = await this.downloadObjectSourceWithData(objectType, objectName, actualData);
+                if (!downloadResult.success) {
+                    const errorMessage = `对象源代码下载失败: ${objectType} - ${objectName}, 错误: ${downloadResult.error}`;
+                    console.warn(errorMessage);
+                    // 记录下载失败到错误列表
+                    // 使用统一的文件路径生成器
+                    const expectedFilePath = this.generateFilePath(objectName, objectType);
+                    this.handleDownloadError(objectName, objectType, expectedFilePath, downloadResult.error);
+                }
+                // 处理函数引用内容
+                if (objectType.toUpperCase() === 'FUNCTION' && actualData.ET_FUNCTION && Array.isArray(actualData.ET_FUNCTION)) {
+                    // 提取函数组信息并生成函数组文件
+                    await this.processFunctionGroup(actualData.ET_FUNCTION, objectName);
+                    for (const func of actualData.ET_FUNCTION) {
+                        const functionName = func.FUNCTIONNAME || objectName;
+                        const progName = func.PROGNAME ? func.PROGNAME : ''; // 获取PROGNAME用于屏幕缓存
+                        // 处理包含文件
+                        if (func.IINCLUDES && Array.isArray(func.IINCLUDES) && func.IINCLUDES.length > 0) {
+                            console.error(`处理函数 ${functionName} 的包含文件，共 ${func.IINCLUDES.length} 个`);
+                            await this.processIncludes(func.IINCLUDES);
+                        }
+                        // 处理结构体
+                        if (func.IDICTSTRUCT && Array.isArray(func.IDICTSTRUCT) && func.IDICTSTRUCT.length > 0) {
+                            console.error(`处理函数 ${functionName} 的结构体，共 ${func.IDICTSTRUCT.length} 个`);
+                            await this.processStructures(func.IDICTSTRUCT);
+                        }
+                        // 处理文本元素
+                        if (func.ITEXTELEMENTS && Array.isArray(func.ITEXTELEMENTS) && func.ITEXTELEMENTS.length > 0) {
+                            await this.processTextElements(func.ITEXTELEMENTS, functionName, 'FUNCTION');
+                        }
+                        // 处理消息
+                        if (func.IMESSAGES && Array.isArray(func.IMESSAGES) && func.IMESSAGES.length > 0) {
+                            await this.processMessages(func.IMESSAGES, functionName, 'FUNCTION');
+                        }
+                        // 处理GUI标题
+                        if (func.IGUITITLE && Array.isArray(func.IGUITITLE) && func.IGUITITLE.length > 0) {
+                            await this.processGuiTitles(func.IGUITITLE, functionName, 'FUNCTION');
+                        }
+                        // 直接添加屏幕数据到缓存（使用PROGNAME）
+                        (0, generate_1.addScreenDataToCache)(this.screenCache, progName, func.ISCREENFIELD, func.ISCREENFLOW, func.ISCREENDESC);
+                    }
+                }
+                // 处理程序引用内容
+                if (objectType.toUpperCase() === 'PROGRAM' && actualData.ET_PROGRAM && Array.isArray(actualData.ET_PROGRAM)) {
+                    for (const prog of actualData.ET_PROGRAM) {
+                        const programName = prog.PROGNAME || objectName;
+                        // 处理包含文件
+                        if (prog.IINCLUDES && Array.isArray(prog.IINCLUDES) && prog.IINCLUDES.length > 0) {
+                            console.error(`处理程序 ${programName} 的包含文件，共 ${prog.IINCLUDES.length} 个`);
+                            await this.processIncludes(prog.IINCLUDES);
+                        }
+                        // 处理结构体
+                        if (prog.IDICTSTRUCT && Array.isArray(prog.IDICTSTRUCT) && prog.IDICTSTRUCT.length > 0) {
+                            console.error(`处理程序 ${programName} 的结构体，共 ${prog.IDICTSTRUCT.length} 个`);
+                            await this.processStructures(prog.IDICTSTRUCT);
+                        }
+                        // 处理文本元素
+                        if (prog.ITEXTELEMENTS && Array.isArray(prog.ITEXTELEMENTS) && prog.ITEXTELEMENTS.length > 0) {
+                            await this.processTextElements(prog.ITEXTELEMENTS, programName, 'PROGRAM');
+                        }
+                        // 处理消息
+                        if (prog.IMESSAGES && Array.isArray(prog.IMESSAGES) && prog.IMESSAGES.length > 0) {
+                            await this.processMessages(prog.IMESSAGES, programName, 'PROGRAM');
+                        }
+                        // 处理GUI标题
+                        if (prog.IGUITITLE && Array.isArray(prog.IGUITITLE) && prog.IGUITITLE.length > 0) {
+                            await this.processGuiTitles(prog.IGUITITLE, programName, 'PROGRAM');
+                        }
+                        // 直接添加屏幕数据到缓存
+                        (0, generate_1.addScreenDataToCache)(this.screenCache, programName, prog.ISCREENFIELD, prog.ISCREENFLOW, prog.ISCREENDESC);
+                    }
+                }
+                // 处理类引用内容
+                if (objectType.toUpperCase() === 'CLASS' && actualData.ET_CLASSES && Array.isArray(actualData.ET_CLASSES)) {
+                    for (const cls of actualData.ET_CLASSES) {
+                        const className = cls.CLSNAME || objectName;
+                        // 处理结构体
+                        if (cls.IDICTSTRUCT && Array.isArray(cls.IDICTSTRUCT) && cls.IDICTSTRUCT.length > 0) {
+                            console.error(`处理类 ${className} 的结构体，共 ${cls.IDICTSTRUCT.length} 个`);
+                            await this.processStructures(cls.IDICTSTRUCT);
+                        }
+                        // 处理文本元素
+                        if (cls.ITEXTELEMENTS && Array.isArray(cls.ITEXTELEMENTS) && cls.ITEXTELEMENTS.length > 0) {
+                            await this.processTextElements(cls.ITEXTELEMENTS, className, 'CLASS');
+                        }
+                        // 处理消息
+                        if (cls.IMESSAGES && Array.isArray(cls.IMESSAGES) && cls.IMESSAGES.length > 0) {
+                            await this.processMessages(cls.IMESSAGES, className, 'CLASS');
+                        }
+                    }
+                }
+                return { success: true, data: actualData };
+            }
+            else {
+                return { success: false, error: '无有效数据返回' };
+            }
+        }
+        catch (error) {
+            const errorMessage = `查询对象引用内容失败: ${objectType} - ${objectName}, 错误: ${error instanceof Error ? error.message : String(error)}`;
+            return { success: false, error: errorMessage };
+        }
+    }
+    /**
+     * 生成对象键
+     */
+    generateObjectKey(objectType, objectName) {
+        return `${objectType}:${objectName}`;
+    }
+    /**
+     * 延迟函数
+     */
+    delay(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * 获取结果摘要
+     */
+    getResultSummary() {
+        const stats = this.result.statistics;
+        const fileErrorCount = this.result.downloadedFiles.filter(f => !f.success).length;
+        return `
+递归查询结果摘要:
+========================
+总对象数: ${stats.totalObjects}
+总类数: ${stats.totalClasses}
+总函数数: ${stats.totalFunctions}
+总包含文件数: ${stats.totalIncludes}
+已下载包含文件: ${stats.downloadedIncludes}
+总结构体数: ${stats.totalStructures}
+已下载结构体数: ${stats.downloadedStructures}
+总domain数: ${stats.totalDomains}
+已下载domain数: ${stats.downloadedDomains}
+最大递归深度: ${stats.maxDepthReached}
+循环引用数: ${stats.circularReferences}
+错误数: ${this.result.errors.length}
+文件错误数: ${fileErrorCount}
+        `.trim();
+    }
+    /**
+     * 获取文件错误详细信息
+     */
+    getFileErrorDetails() {
+        const failedFiles = this.result.downloadedFiles.filter(f => !f.success);
+        if (failedFiles.length === 0) {
+            return '';
+        }
+        let details = '\n文件错误详情:\n';
+        details += '========================\n';
+        failedFiles.forEach((file, index) => {
+            details += `${index + 1}. ${file.objectType} - ${file.objectName}\n`;
+            details += `   错误: ${file.error || '未知错误'}\n`;
+            details += `   路径: ${file.filePath}\n\n`;
+        });
+        return details;
+    }
+}
+exports.RecursiveObjectQuery = RecursiveObjectQuery;