@lcap/nasl 4.4.0-rc.2 → 4.4.1-rc.2

package/out/natural/exports/transform2BatchActions.js

@@ -17,6 +17,8 @@
  * - enum: 枚举类型
  * - logic: 业务逻辑
  * - view: 视图组件
+ * - backendVariables: 后端变量
+ * - frontendVariables: 前端类型变量
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyBatchActions = exports.transform2BatchActions = exports.generateRouterContainerTemplate = void 0;
@@ -24,6 +26,13 @@ const uuid_1 = require("uuid");
 const concepts_1 = require("../../concepts");
 const index_1 = require("../../index");
 const utils_1 = require("../../utils");
+const nasl_file_types_1 = require("../utils/nasl-file-types");
+/**
+ * 检查项目类型是否允许空名称
+ */
+const isNameOptional = (itemType) => {
+    return ['backendVariables', 'frontendVariables', 'theme'].includes(itemType);
+};
 /**
  * 生成空的路由容器模板
  * 用于为嵌套视图创建父级容器视图
@@ -62,6 +71,14 @@ const getItemType = (namespace) => {
         return 'logic';
     if (namespace.includes('views'))
         return 'view';
+    if (namespace.includes('extensions'))
+        return 'extensions';
+    if (namespace.includes('app.backend.variables'))
+        return 'backendVariables';
+    if (namespace.includes('theme.css'))
+        return 'theme';
+    if (/app\.frontendTypes\.[^.]+\.frontends\.[^.]+\.variables/.test(namespace))
+        return 'frontendVariables';
     return 'unknown';
 };
 /**
@@ -141,74 +158,400 @@ const buildNestedViewPath = (parentViewNames, viewName) => {
  * @param parentViewNames - 可选的父级视图名称数组
  * @returns 找到的视图节点或 undefined
  */
-const createViewFinder = (instance) => (name, parentViewNames) => {
-    if (parentViewNames && parentViewNames.length > 0) {
-        // 对于嵌套视图，使用路径查找
-        const viewPath = buildNestedViewPath(parentViewNames, name);
-        return instance?.findNodeByPath(viewPath);
-    }
+const createViewFinder = (instance) => (name, parentViewNames = []) => {
+    // if (parentViewNames && parentViewNames.length > 0) {
+    //   // 对于嵌套视图，使用路径查找
+    // }
+    const viewPath = buildNestedViewPath(parentViewNames, name);
+    return instance?.findNodeByPath(viewPath);
     // 顶级视图使用 findViewByName
-    return instance?.frontendTypes?.[0]?.frontends?.[0]?.findViewByName(name);
+    // return instance?.frontendTypes?.[0]?.frontends?.[0]?.findViewByName(name);
+};
+/**
+ * 类型守卫：判断是否为单节点处理器
+ */
+const isSingleNodeHandler = (handler) => {
+    return ['entity', 'structure', 'enum', 'logic'].includes(handler.type);
+};
+/**
+ * 类型守卫：判断是否为视图处理器
+ */
+const isViewHandler = (handler) => {
+    return handler.type === 'view';
+};
+/**
+ * 类型守卫：判断是否为全局变量处理器
+ */
+const isGlobalVariablesHandler = (handler) => {
+    return ['backendVariables', 'frontendVariables'].includes(handler.type);
+};
+/**
+ * 类型守卫：判断是否为主题处理器
+ */
+const isThemeHandler = (handler) => {
+    return handler.type === 'theme';
 };
 /**
  * 创建不同类型处理器的工厂函数
- * 为每种类型（entity、structure、enum、logic、view）提供统一的操作接口
+ * 为每种类型（entity、structure、enum、logic、view、backendVariables、frontendVariables）提供统一的操作接口
  * @param appInstance - 解析后的应用实例，用于查找新创建的对象
  * @param app - 目前已有的应用实例，用于查找已存在的对象和添加新对象
  * @returns 包含各种类型处理器的对象
  */
 const createTypeHandlers = (appInstance, app) => ({
     entity: {
+        type: 'entity',
         /** 实体在应用中的路径模板 */
         path: 'app.dataSources[name=defaultDS].entities[0]',
         /** 从解析实例中查找实体的方法 */
         findMethod: (name) => appInstance?.dataSources?.[0]?.findEntityByName(name),
         /** 从目标应用中查找已存在实体的方法 */
         findExisting: (name) => app.dataSources?.[0]?.findEntityByName(name),
-        /** 向目标应用添加实体的方法 */
-        addMethod: (json) => app.dataSources[0].addEntity(json),
     },
     structure: {
+        type: 'structure',
         /** 结构体在应用中的路径模板 */
         path: 'app.structures[0]',
         /** 从解析实例中查找结构体的方法 */
         findMethod: (name) => appInstance?.findStructureByName(name),
         /** 从目标应用中查找已存在结构体的方法 */
         findExisting: (name) => app.findStructureByName(name),
-        /** 向目标应用添加结构体的方法 */
-        addMethod: (json) => app.addStructure(json),
     },
     enum: {
+        type: 'enum',
         /** 枚举在应用中的路径模板 */
         path: 'app.enums[0]',
         /** 从解析实例中查找枚举的方法 */
         findMethod: (name) => appInstance?.findEnumByName(name),
         /** 从目标应用中查找已存在枚举的方法 */
         findExisting: (name) => app.findEnumByName(name),
-        /** 向目标应用添加枚举的方法 */
-        addMethod: (json) => app.addEnum(json),
     },
     logic: {
+        type: 'logic',
         /** 逻辑在应用中的路径模板 */
         path: 'app.logics[0]',
         /** 从解析实例中查找逻辑的方法 */
         findMethod: (name) => appInstance?.findLogicByName(name),
         /** 从目标应用中查找已存在逻辑的方法 */
         findExisting: (name) => app.findLogicByName(name),
-        /** 向目标应用添加逻辑的方法 */
-        addMethod: (json) => app.addLogic(json),
     },
     view: {
+        type: 'view',
         /** 视图在应用中的路径模板 */
         path: 'app.frontendTypes[name=pc].frontends[name=pc].views[0]',
         /** 从解析实例中查找视图的方法 */
         findMethod: createViewFinder(appInstance),
         /** 从目标应用中查找已存在视图的方法 */
         findExisting: createViewFinder(app),
-        /** 向目标应用添加视图的方法 */
-        addMethod: (json) => app.frontendTypes[0].frontends[0].addView(json),
     },
+    backendVariables: {
+        type: 'backendVariables',
+        /** 后端全局变量在应用中的路径 */
+        path: 'app.backend.variables[0]',
+        /** 从解析实例中查找后端变量 */
+        findMethod: (name) => {
+            if (!name)
+                return appInstance?.backend;
+            const path = `app.backend.variables[name=${name}]`;
+            return appInstance?.findNodeByPath(path);
+        },
+        /** 从目标应用中查找已存在的后端变量 */
+        findExisting: (name) => {
+            if (!name)
+                return app.backend;
+            const path = `app.backend.variables[name=${name}]`;
+            return app.findNodeByPath(path);
+        },
+    },
+    frontendVariables: {
+        type: 'frontendVariables',
+        /** 前端全局变量在应用中的路径 */
+        path: 'app.frontendTypes[name=pc].frontends[name=pc].variables[0]',
+        /** 从解析实例中查找前端变量 */
+        findMethod: (name) => {
+            if (!name)
+                return appInstance?.frontendTypes?.[0]?.frontends?.[0];
+            const path = `app.frontendTypes[name=pc].frontends[name=pc].variables[name=${name}]`;
+            return appInstance?.findNodeByPath(path);
+        },
+        /** 从目标应用中查找已存在的前端变量 */
+        findExisting: (name) => {
+            if (!name)
+                return app.frontendTypes?.[0]?.frontends?.[0];
+            const path = `app.frontendTypes[name=pc].frontends[name=pc].variables[name=${name}]`;
+            return app.findNodeByPath(path);
+        },
+    },
+    theme: {
+        type: 'theme',
+        /** 主题在应用中的路径 */
+        path: 'app.frontendTypes[name=pc].frontends[name=pc].theme',
+        /** 从解析实例中查找主题 */
+        findMethod: () => appInstance?.frontendTypes?.[0]?.frontends?.[0]?.theme,
+        /** 从目标应用中查找已存在的主题 */
+        findExisting: () => app.frontendTypes?.[0]?.frontends?.[0]?.theme,
+    },
+    // 后续需要扩展 extensions 的
 });
+/**
+ * 通用删除操作处理
+ * @param params - 删除操作参数
+ */
+const handleDeleteOperation = (params) => {
+    const { handler, itemName, itemType, batchActions, errors, parentViewNames, errorMessageTemplate = `要删除的对象不存在: ${itemName}`, } = params;
+    // 根据 handler 类型调用不同的 findExisting 方法
+    let existingNode;
+    if (isViewHandler(handler)) {
+        existingNode = handler.findExisting(itemName, parentViewNames);
+    }
+    else if (isSingleNodeHandler(handler)) {
+        existingNode = handler.findExisting(itemName);
+    }
+    else if (isGlobalVariablesHandler(handler)) {
+        existingNode = handler.findExisting(itemName);
+    }
+    if (existingNode) {
+        batchActions.actions.push({
+            action: 'delete',
+            path: existingNode.nodePath,
+            object: null,
+        });
+    }
+    else {
+        errors.push({
+            item: itemName,
+            type: itemType,
+            error: new Error(errorMessageTemplate),
+            level: 1,
+        });
+    }
+};
+/**
+ * 处理变量创建或更新操作
+ */
+const handleVariableCreateOrUpdate = (handler, variable, variableName, batchActions) => {
+    const existingVar = handler.findExisting(variableName);
+    const variableObject = variable.toJSON();
+    if (existingVar) {
+        // 更新操作
+        batchActions.actions.push({
+            action: 'update',
+            path: existingVar.nodePath,
+            object: variableObject,
+        });
+    }
+    else {
+        // 创建操作
+        batchActions.actions.push({
+            action: 'create',
+            path: handler.path,
+            object: variableObject,
+        });
+    }
+};
+/**
+ * 处理全局变量类型（一个文件对应多个节点）
+ */
+const processGlobalVariables = (params) => {
+    const { handler, action, itemType, batchActions, errors } = params;
+    // 系统保留变量，不允许删除、创建或更新
+    const RESERVED_VARIABLES = new Set(['httpRequest', 'httpResponse', 'currentUser']);
+    // 获取容器节点（backend 或 frontend）
+    const container = handler.findMethod();
+    if (!container || !container.variables) {
+        errors.push({
+            item: itemType,
+            type: itemType,
+            error: new Error(`未找到${itemType}容器或variables属性`),
+            level: 2,
+        });
+        return;
+    }
+    // 处理删除操作的特殊情况
+    if (action === 'delete') {
+        for (const variable of container.variables) {
+            const variableName = variable.name;
+            if (!variableName || RESERVED_VARIABLES.has(variableName))
+                continue;
+            try {
+                handleDeleteOperation({
+                    handler,
+                    itemName: variableName,
+                    itemType,
+                    batchActions,
+                    errors,
+                    errorMessageTemplate: `要删除的变量不存在: ${variableName}`,
+                });
+            }
+            catch (error) {
+                errors.push({
+                    item: variableName,
+                    type: itemType,
+                    error: error,
+                    level: 3,
+                });
+            }
+        }
+        return;
+    }
+    // 处理创建和更新操作
+    // 一次性获取现有容器，避免重复调用
+    const existingContainer = handler.findExisting();
+    // 构建新变量名的 Set（只在有现有容器时才需要）
+    const newVariableNames = existingContainer?.variables ? new Set() : null;
+    // 第一遍：处理新变量的创建/更新
+    for (const variable of container.variables) {
+        const variableName = variable.name;
+        if (!variableName || RESERVED_VARIABLES.has(variableName))
+            continue;
+        // 同时收集变量名（避免额外的 map 操作）
+        newVariableNames?.add(variableName);
+        try {
+            handleVariableCreateOrUpdate(handler, variable, variableName, batchActions);
+        }
+        catch (error) {
+            errors.push({
+                item: variableName,
+                type: itemType,
+                error: error,
+                level: 3,
+            });
+        }
+    }
+    // 第二遍：处理需要删除的旧变量（app 中有但 appInstance 中没有的，目前以 spec 生成为准，如果后续不需要，这块可以隐藏）
+    if (existingContainer?.variables && newVariableNames) {
+        for (const existingVariable of existingContainer.variables) {
+            const existingVariableName = existingVariable.name;
+            if (!existingVariableName ||
+                RESERVED_VARIABLES.has(existingVariableName) ||
+                newVariableNames.has(existingVariableName)) {
+                continue;
+            }
+            // 变量在 appInstance 中不存在，按 delete 处理
+            try {
+                handleDeleteOperation({
+                    handler,
+                    itemName: existingVariableName,
+                    itemType,
+                    batchActions,
+                    errors,
+                    errorMessageTemplate: `要删除的变量不存在: ${existingVariableName}`,
+                });
+            }
+            catch (error) {
+                errors.push({
+                    item: existingVariableName,
+                    type: itemType,
+                    error: error,
+                    level: 3,
+                });
+            }
+        }
+    }
+};
+/**
+ * 计算 view 类型的路径
+ */
+const calculateViewPath = (naslObject) => {
+    let type = 'views';
+    if (naslObject.parentNode?.concept === 'View') {
+        type = 'children';
+    }
+    const parentChildren = naslObject.parentNode?.[type] || [];
+    const childIndex = parentChildren.findIndex((child) => child === naslObject);
+    const index = childIndex !== -1 ? childIndex : 0;
+    return `${naslObject.parentNode.nodePath}.${type}[${index}]`;
+};
+/**
+ * 处理 view 类型的 children 属性
+ */
+const handleViewChildren = (object, action) => {
+    if (action === 'create') {
+        // 对于创建操作，需要将 children 数组转换为空数组
+        object.children = [];
+    }
+    else if (action === 'update') {
+        // 对于更新操作，删除 children 属性
+        if (object.children) {
+            delete object.children;
+        }
+    }
+};
+/**
+ * 处理单节点创建或更新操作
+ */
+const handleSingleNodeCreateOrUpdate = (handler, itemName, itemType, parentViewNames, batchActions, errors) => {
+    // 从解析的实例中获取 NASL 对象
+    let naslObject;
+    // 根据 handler 类型调用不同的 findMethod
+    if (isViewHandler(handler)) {
+        naslObject = handler.findMethod(itemName, parentViewNames);
+    }
+    else {
+        naslObject = handler.findMethod(itemName);
+    }
+    if (!naslObject) {
+        errors.push({
+            item: itemName,
+            type: itemType,
+            error: new Error(`未找到对应的 NASL 对象: ${handler.path} - ${itemName}`),
+            level: 2,
+        });
+        return;
+    }
+    let finalAction = 'create';
+    let path = '';
+    let object = naslObject.toJSON();
+    // 特殊处理：对于 view 类型，计算正确的路径
+    if (itemType === 'view' && naslObject.parentNode) {
+        path = calculateViewPath(naslObject);
+    }
+    // 检查目标应用中是否已存在同名对象
+    let existingNode;
+    if (isViewHandler(handler)) {
+        existingNode = handler.findExisting(itemName, parentViewNames);
+    }
+    else {
+        existingNode = handler.findExisting(itemName);
+    }
+    if (existingNode) {
+        // 存在同名对象，标记为更新操作
+        finalAction = 'update';
+        path = existingNode.nodePath;
+    }
+    // 特殊处理 view 类型的 children 属性
+    if (itemType === 'view') {
+        handleViewChildren(object, finalAction);
+    }
+    // 添加创建或更新操作到批量操作列表
+    batchActions.actions.push({
+        action: finalAction,
+        path: path || handler.path,
+        object,
+    });
+};
+/**
+ * 处理单节点类型（一个文件对应一个节点）
+ */
+const processSingleNode = (params) => {
+    const { handler, itemName, itemType, action, parentViewNames, batchActions, errors } = params;
+    if (action === 'delete') {
+        // 删除操作：使用通用删除方法
+        handleDeleteOperation({
+            handler,
+            itemName,
+            itemType,
+            batchActions,
+            errors,
+            parentViewNames,
+            errorMessageTemplate: `要删除的对象不存在: ${handler.path} - ${itemName}`,
+        });
+    }
+    else {
+        // 创建或更新操作
+        handleSingleNodeCreateOrUpdate(handler, itemName, itemType, parentViewNames, batchActions, errors);
+    }
+};
 /**
  * 检测并生成缺失的父级视图模板
  * @param path - 当前项的路径
@@ -255,14 +598,37 @@ const transformCodeAction = ({ path, content, action, }) => {
     // 移除路径前缀 'src/'，并解析命名空间
     const namespace = path.replace(/^src\//, '');
     const namespaceParts = namespace.split('.');
-    // 提取项目名称和父命名空间
-    const itemName = namespaceParts.length >= 2 ? namespaceParts[namespaceParts.length - 2] : '';
-    const parentNamespace = namespaceParts.slice(0, -2).join('.');
-    // 根据命名空间确定项目类型
+    // 根据命名空间确定项目类型（需要先确定类型）
     const itemType = getItemType(namespace);
+    // 提取项目名称和父命名空间，对于变量类型需要特殊处理
+    let itemName;
+    let parentNamespace;
+    if (itemType === 'backendVariables' || itemType === 'frontendVariables') {
+        // 对于变量类型，路径格式为: app.backend.variables.ts 或 app.frontendTypes.pc.frontends.pc.variables.ts
+        // itemName 设为空字符串（因为这是整个 variables 文件）
+        // parentNamespace 为去掉 .ts 的部分，即保留到 variables
+        itemName = '';
+        parentNamespace = namespaceParts.slice(0, -1).join('.');
+    }
+    else if (itemType === 'theme') {
+        // 对于主题类型，路径格式为: app.frontendTypes.pc.frontends.pc.theme.css
+        itemName = '';
+        parentNamespace = namespaceParts.slice(0, -1).join('.');
+    }
+    else if (itemType === 'extensions') {
+        parentNamespace = namespaceParts.slice(0, -1).join('.');
+    }
+    else {
+        // 其他类型使用原有逻辑，即单文件模式(例如一个实体对应一个文件)
+        itemName = namespaceParts.length >= 2 ? namespaceParts[namespaceParts.length - 2] : '';
+        parentNamespace = namespaceParts.slice(0, -2).join('.');
+    }
     // 生成转换后的代码，为非未知类型添加命名空间包装
     let transformedCode = content;
-    if (itemType !== 'unknown' && parentNamespace) {
+    if (itemType === 'theme') {
+        transformedCode = `namespace ${parentNamespace} {\n  $theme\`${content}\`;\n}\n`;
+    }
+    else if (itemType !== 'unknown' && parentNamespace) {
         // 对于视图类型，需要额外的缩进
         const indent = itemType === 'view' ? '    ' : '';
         transformedCode = `namespace ${parentNamespace} {\n${indent}${content}\n}\n`;
@@ -310,8 +676,13 @@ const transform2BatchActions = ({ codeActions, app, sessionId, type = 'normal',
     // 第一阶段：转换所有codeAction
     for (const item of codeActions) {
         try {
-            // 检查文件后缀，目前一期只处理 .ts 和 .tsx 文件
-            if (!item.path.endsWith('.ts') && !item.path.endsWith('.tsx')) {
+            // 检查文件后缀，目前只处理 .ts、.tsx 和 .css 文件
+            if (!item.path.endsWith('.ts') &&
+                !item.path.endsWith('.tsx') &&
+                !item.path.endsWith('.css')) {
+                continue;
+            }
+            if (!(0, nasl_file_types_1.isKnownFileType)(item.path)) {
                 continue;
             }
             // 检测并生成缺失的父级视图
@@ -320,6 +691,9 @@ const transform2BatchActions = ({ codeActions, app, sessionId, type = 'normal',
             }
             // 处理当前项
             const { transformedCode, itemType, itemName, action, parentViewNames } = transformCodeAction(item);
+            // 跳过未知类型的 codeAction/暂时禁用 extensions
+            if (itemType === 'unknown' || itemType === 'extensions')
+                continue;
             // 只有非删除操作才需要累积代码用于解析，因为删除操作不需要解析新的 NASL 对象
             if (action !== 'delete') {
                 codeArray.push(transformedCode);
@@ -370,86 +744,73 @@ const transform2BatchActions = ({ codeActions, app, sessionId, type = 'normal',
     // 第三阶段：生成批量操作
     // 获取不同类型的处理器
     const typeHandlers = createTypeHandlers(appInstance, app);
+    // 收集所有要删除的视图名称，用于跳过冗余的子视图删除操作
+    const deletedViewNames = new Set(itemTypes
+        .filter(({ type, action }) => type === 'view' && action === 'delete')
+        .map(({ name }) => name));
     // 遍历每个项目，生成对应的批量操作
     for (const { type: itemType, name: itemName, action, parentViewNames } of itemTypes) {
-        // 跳过未知类型或无名称的项目
-        if (itemType === 'unknown' || !itemName)
+        // 跳过未知类型，或者非可选名称但无名称的项目
+        if (itemType === 'unknown' || (!isNameOptional(itemType) && !itemName))
             continue;
+        // 如果父级视图已在删除列表中，子视图无需单独删除（父视图删除时会级联删除子视图）
+        if (itemType === 'view' && action === 'delete' && parentViewNames?.some((p) => deletedViewNames.has(p))) {
+            continue;
+        }
         try {
             const handler = typeHandlers[itemType];
             if (!handler)
                 continue;
-            // 根据操作类型执行不同的处理逻辑
-            if (action === 'delete') {
-                // 删除操作：查找已存在的对象并删除
-                const existingNode = handler.findExisting(itemName, parentViewNames);
-                if (existingNode) {
-                    // 添加删除操作到批量操作列表
+            // 使用类型守卫进行精确的类型判断和处理
+            if (isThemeHandler(handler)) {
+                // 主题类型：无需参数
+                const naslObject = handler.findMethod();
+                if (naslObject) {
+                    const existingNode = handler.findExisting();
                     batchActions.actions.push({
-                        action: 'delete',
-                        path: existingNode.nodePath,
-                        object: null,
-                    });
-                }
-                else {
-                    // 要删除的对象不存在，记录错误
-                    errors.push({
-                        item: itemName,
-                        type: itemType,
-                        error: new Error(`要删除的对象不存在: ${handler.path} - ${itemName}`),
-                        level: 1,
+                        action: 'update',
+                        path: existingNode?.nodePath || handler.path,
+                        object: {
+                            // 暂时只支持 scopeVariableMap + cssRules
+                            ...existingNode.toJSON(),
+                            scopeVariableMap: naslObject.scopeVariableMap,
+                            cssRules: naslObject.cssRules,
+                        },
                     });
                 }
             }
-            else {
-                // 创建或更新操作：从解析的实例中获取 NASL 对象
-                const naslObject = handler.findMethod(itemName, parentViewNames);
-                if (!naslObject) {
-                    errors.push({
-                        item: itemName,
-                        type: itemType,
-                        error: new Error(`未找到对应的 NASL 对象: ${handler.path} - ${itemName}`),
-                        level: 2,
-                    });
-                    continue;
-                }
-                let finalAction = 'create';
-                let path = '';
-                let object = naslObject.toJSON();
-                // 特殊处理：对于 view 类型，判断父级 view 是否存在于 itemTypes 中
-                if (itemType === 'view' && naslObject.parentNode) {
-                    // 找到当前节点在父节点 children 中的实际索引
-                    let type = 'views';
-                    if (naslObject.parentNode?.concept === 'View') {
-                        type = 'children';
-                    }
-                    const parentChildren = naslObject.parentNode?.[type] || [];
-                    const childIndex = parentChildren.findIndex((child) => child === naslObject);
-                    const index = childIndex !== -1 ? childIndex : 0;
-                    path = `${naslObject.parentNode.nodePath}.${type}[${index}]`;
-                }
-                // 检查目标应用中是否已存在同名对象
-                const existingNode = handler.findExisting(itemName, parentViewNames);
-                if (existingNode) {
-                    // 存在同名对象，标记为更新操作
-                    finalAction = 'update';
-                    path = existingNode.nodePath;
-                }
-                if (itemType === 'view') {
-                    if (finalAction === 'create') {
-                        // 对于创建操作，需要将 children 数组转换为对象
-                        object.children = [];
-                    }
-                    if (finalAction === 'update') {
-                        if (object.children)
-                            delete object.children;
-                    }
-                }
-                // 添加创建或更新操作到批量操作列表
-                batchActions.actions.push({
-                    action: finalAction,
-                    path: path || handler.path,
-                    object,
+            else if (isGlobalVariablesHandler(handler)) {
+                // 全局变量类型：一个文件对应多个节点
+                processGlobalVariables({
+                    handler,
+                    action,
+                    itemType,
+                    batchActions,
+                    errors,
+                });
+            }
+            else if (isViewHandler(handler)) {
+                // 视图类型：一个文件对应一个节点，支持嵌套视图
+                processSingleNode({
+                    handler,
+                    itemName,
+                    itemType,
+                    action,
+                    parentViewNames,
+                    batchActions,
+                    errors,
+                });
+            }
+            else if (isSingleNodeHandler(handler)) {
+                // 单节点类型：entity, structure, enum, logic
+                processSingleNode({
+                    handler,
+                    itemName,
+                    itemType,
+                    action,
+                    parentViewNames,
+                    batchActions,
+                    errors,
                 });
             }
         }
@@ -463,6 +824,10 @@ const transform2BatchActions = ({ codeActions, app, sessionId, type = 'normal',
             });
         }
     }
+    // 第五阶段：同步 directories（只处理 appInstance 中已存在的）
+    if (appInstance && app) {
+        handleAppDirectories(appInstance, app, batchActions, errors);
+    }
     // 第四阶段：错误处理和结果返回
     // 如果有错误发生，在控制台输出错误信息（但不中断执行）
     if (errors.length > 0) {
@@ -471,12 +836,12 @@ const transform2BatchActions = ({ codeActions, app, sessionId, type = 'normal',
     // 构建返回结果，基础结果包含批量操作
     let result = {
         batchActions,
+        accumulatedTsCode, // 累积的 TypeScript 代码
     };
     // 调试模式下返回额外的调试信息
     if (type === 'debug') {
         result = {
             ...result,
-            accumulatedTsCode, // 累积的 TypeScript 代码
             parseJSON, // 解析后的 JSON 对象
             errors, // 错误列表
         };
@@ -487,6 +852,307 @@ const transform2BatchActions = ({ codeActions, app, sessionId, type = 'normal',
     return result;
 };
 exports.transform2BatchActions = transform2BatchActions;
+/**
+ * 构建全局 definition 索引
+ * 一次性构建，避免重复遍历
+ * @param allDirs - 所有目录数组
+ * @returns 全局索引对象
+ */
+const buildGlobalDefIndex = (allDirs) => {
+    const defMap = new Map();
+    const dirDefMap = new Map();
+    for (const dir of allDirs) {
+        if (!dir?.definitions || !dir.name)
+            continue;
+        const defKeys = new Set();
+        for (const def of dir.definitions) {
+            if (!def)
+                continue;
+            const key = `${def.namespace}:${def.name}`;
+            defMap.set(key, {
+                def,
+                dirName: dir.name,
+                dirPath: dir.nodePath,
+            });
+            defKeys.add(key);
+        }
+        if (defKeys.size > 0) {
+            dirDefMap.set(dir.name, defKeys);
+        }
+    }
+    return { defMap, dirDefMap };
+};
+/**
+ * 深度比较两个 definition 是否需要更新
+ * 只比较关键属性，避免不必要的序列化
+ * @param appDef - app 中的 definition
+ * @param instanceDef - appInstance 中的 definition
+ * @returns 是否需要更新
+ */
+const needsDefinitionUpdate = (appDef, instanceDef) => {
+    // 快速检查：引用相等
+    if (appDef === instanceDef)
+        return false;
+    // 关键属性比较
+    return (appDef.referredConcept !== instanceDef.referredConcept ||
+        appDef.namespace !== instanceDef.namespace ||
+        appDef.name !== instanceDef.name);
+};
+/**
+ * 同步目录的 definitions
+ * 使用 Map 替代数组查找，使用全局索引避免重复遍历
+ * @param instanceDir - appInstance 中的目录
+ * @param appDir - app 中对应的目录
+ * @param globalDefIndex - 全局 definition 索引
+ * @param pendingActions - 待添加的批量操作数组
+ * @param errors - 错误收集数组
+ */
+const syncDirectoryDefinitions = (instanceDir, appDir, globalDefIndex, pendingActions, errors) => {
+    try {
+        // 快速检查
+        if (!instanceDir?.definitions || instanceDir.definitions.length === 0) {
+            return;
+        }
+        // 构建当前目录的 definition Map
+        const appDefMap = new Map((appDir?.definitions || []).map((def) => [`${def.namespace}:${def.name}`, def]));
+        for (const instanceDef of instanceDir.definitions) {
+            if (!instanceDef)
+                continue;
+            const key = `${instanceDef.namespace}:${instanceDef.name}`;
+            const defObject = instanceDef.toJSON();
+            // 第一步：在当前目录查找
+            const appDefInCurrentDir = appDefMap.get(key);
+            if (appDefInCurrentDir) {
+                // 在当前目录找到了，检查是否需要更新
+                if (needsDefinitionUpdate(appDefInCurrentDir, instanceDef)) {
+                    // 内容不同，更新（先删除再创建）
+                    pendingActions.push({
+                        action: 'delete',
+                        path: appDefInCurrentDir.nodePath,
+                        object: null,
+                    }, {
+                        action: 'create',
+                        path: `${appDir.nodePath}.definitions[0]`,
+                        object: defObject,
+                    });
+                }
+                // 内容相同则跳过
+            }
+            else {
+                // 第二步：使用全局索引查找其他目录
+                const defInOtherDir = globalDefIndex.defMap.get(key);
+                if (defInOtherDir && defInOtherDir.dirName !== appDir.name) {
+                    // 在其他文件夹找到了 → 文件移动场景
+                    // 先删除旧位置的引用
+                    pendingActions.push({
+                        action: 'delete',
+                        path: defInOtherDir.def.nodePath,
+                        object: null,
+                    });
+                }
+                // 然后在当前目录创建新引用（无论是移动还是新建）
+                pendingActions.push({
+                    action: 'create',
+                    path: `${appDir.nodePath}.definitions[0]`,
+                    object: defObject,
+                });
+            }
+        }
+    }
+    catch (error) {
+        errors.push({
+            item: instanceDir?.name || 'unknown',
+            type: 'definitionSync',
+            error: error,
+            level: 4,
+        });
+    }
+};
+/**
+ * 删除新目录中的 definitions 在其他目录中的旧引用
+ * 使用全局索引，避免重复构建 Map
+ * @param instanceDir - 新目录
+ * @param globalDefIndex - 全局 definition 索引
+ * @param pendingActions - 待添加的批量操作数组
+ */
+const deleteOldDefinitionReferences = (instanceDir, globalDefIndex, pendingActions) => {
+    if (!instanceDir?.definitions || instanceDir.definitions.length === 0) {
+        return;
+    }
+    // 直接使用全局索引查找
+    for (const instanceDef of instanceDir.definitions) {
+        if (!instanceDef)
+            continue;
+        const key = `${instanceDef.namespace}:${instanceDef.name}`;
+        const oldDef = globalDefIndex.defMap.get(key);
+        if (oldDef) {
+            // 找到了旧引用，删除它
+            pendingActions.push({
+                action: 'delete',
+                path: oldDef.def.nodePath,
+                object: null,
+            });
+        }
+    }
+};
+/**
+ * 同步单个目录
+ * 通用的目录同步逻辑，适用于所有类型的目录
+ * @param instanceDir - appInstance 中的目录
+ * @param appDir - app 中对应的目录（可能不存在）
+ * @param globalDefIndex - 全局 definition 索引
+ * @param parentPath - 父级路径
+ * @param pendingActions - 待添加的批量操作数组
+ * @param errors - 错误收集数组
+ * @param errorType - 错误类型标识
+ */
+const syncSingleDirectory = (instanceDir, appDir, globalDefIndex, parentPath, pendingActions, errors, errorType) => {
+    try {
+        if (!appDir) {
+            // 目录不存在，需要创建
+            // 先删除该目录中 definitions 在其他目录的旧引用
+            deleteOldDefinitionReferences(instanceDir, globalDefIndex, pendingActions);
+            // 然后创建完整的新目录
+            const dirObject = instanceDir.toJSON();
+            pendingActions.push({
+                action: 'create',
+                path: parentPath,
+                object: dirObject,
+            });
+        }
+        else {
+            // 目录存在，同步 definitions
+            syncDirectoryDefinitions(instanceDir, appDir, globalDefIndex, pendingActions, errors);
+        }
+    }
+    catch (error) {
+        errors.push({
+            item: instanceDir?.name || 'unknown',
+            type: errorType,
+            error: error,
+            level: 4,
+        });
+    }
+};
+/**
+ * 处理 app directories 同步
+ * 处理四种 directories: 'LOGICS', 'ENUMS', 'STRUCTURES' 以及 appInstance.dataSources[0] 的 directories
+ * 比对 directories 及引用 definitions，最小粒度是 definition，唯一标识是 namespace+name
+ * 文件夹只做新增更新，definition 如果在同一领域的文件夹下，需要先删除原引用，再创建新引用
+ *
+ * 性能优化:
+ * 1. 全局 definition 索引缓存 - 避免重复构建
+ * 3. 批量操作收集 - 减少数组扩容
+ * 4. 提前验证和快速退出 - 避免无效处理
+ * 5. 优化的 definition 比较 - 只比较关键属性
+ */
+const handleAppDirectories = (appInstance, app, batchActions, errors) => {
+    // 性能计时开始
+    const startTime = performance.now();
+    // 1. 边界检查和快速退出
+    if (!appInstance || !app) {
+        errors.push({
+            item: 'handleAppDirectories',
+            type: 'invalidParams',
+            error: new Error('appInstance 或 app 参数无效'),
+            level: 5,
+        });
+        return;
+    }
+    try {
+        // 2. 快速检查是否有需要处理的目录
+        const hasInstanceDirs = appInstance.directories?.some((dir) => ['LOGICS', 'ENUMS', 'STRUCTURES'].includes(dir?.name) && dir.children?.length > 0);
+        const hasDataSourceDirs = appInstance.dataSources?.[0]?.directories?.length > 0;
+        if (!hasInstanceDirs && !hasDataSourceDirs) {
+            console.log('[handleAppDirectories] 无需处理目录同步');
+            return; // 无需处理
+        }
+        // 3. 批量操作收集器（减少数组扩容）
+        const pendingActions = [];
+        // 4. 处理根目录类型 (LOGICS, ENUMS, STRUCTURES)
+        const rootDirectoryTypes = ['LOGICS', 'ENUMS', 'STRUCTURES'];
+        for (const rootType of rootDirectoryTypes) {
+            try {
+                const instanceRootDir = appInstance.directories?.find((dir) => dir?.name === rootType);
+                if (!instanceRootDir?.children?.length) {
+                    continue;
+                }
+                let appRootDir = app.directories?.find((dir) => dir?.name === rootType);
+                if (!appRootDir) {
+                    // 根目录不存在，直接创建
+                    pendingActions.push({
+                        action: 'create',
+                        path: 'app.directories[0]',
+                        object: instanceRootDir.toJSON(),
+                    });
+                    continue;
+                }
+                // 5. 构建子目录 Map（O(1) 查找，替代数组遍历）
+                const allAppChildDirs = appRootDir.children || [];
+                const appChildDirMap = new Map(allAppChildDirs.filter((dir) => dir?.name).map((dir) => [dir.name, dir]));
+                // 6. 构建全局 definition 索引（一次性构建）
+                const globalDefIndex = buildGlobalDefIndex(allAppChildDirs);
+                // 7. 遍历子目录
+                for (const instanceChildDir of instanceRootDir.children) {
+                    if (!instanceChildDir?.name)
+                        continue;
+                    const appChildDir = appChildDirMap.get(instanceChildDir.name);
+                    syncSingleDirectory(instanceChildDir, appChildDir, globalDefIndex, `${appRootDir.nodePath}.children[0]`, pendingActions, errors, 'directorySync');
+                }
+            }
+            catch (error) {
+                errors.push({
+                    item: rootType,
+                    type: 'rootDirectorySync',
+                    error: error,
+                    level: 4,
+                });
+            }
+        }
+        // 8. 处理数据源 (Entity) directories
+        if (appInstance.dataSources?.[0]?.directories && app.dataSources?.[0]) {
+            try {
+                const instanceDataSource = appInstance.dataSources[0];
+                const appDataSource = app.dataSources[0];
+                const allAppEntityDirs = appDataSource.directories || [];
+                // 构建目录 Map（O(1) 查找）
+                const entityDirMap = new Map(allAppEntityDirs.filter((dir) => dir?.name).map((dir) => [dir.name, dir]));
+                // 构建全局 definition 索引
+                const globalDefIndex = buildGlobalDefIndex(allAppEntityDirs);
+                for (const instanceDir of instanceDataSource.directories) {
+                    if (!instanceDir?.name)
+                        continue;
+                    const appDir = entityDirMap.get(instanceDir.name);
+                    syncSingleDirectory(instanceDir, appDir, globalDefIndex, `${appDataSource.nodePath}.directories[0]`, pendingActions, errors, 'entityDirectorySync');
+                }
+            }
+            catch (error) {
+                errors.push({
+                    item: 'dataSources',
+                    type: 'dataSourceDirectorySync',
+                    error: error,
+                    level: 4,
+                });
+            }
+        }
+        // 9. 批量添加所有操作（一次性 push，减少数组扩容）
+        if (pendingActions.length > 0) {
+            batchActions.actions.push(...pendingActions);
+            console.log(`[handleAppDirectories] 生成 ${pendingActions.length} 个批量操作`);
+        }
+        // 性能计时结束
+        const endTime = performance.now();
+        console.log(`[handleAppDirectories] 执行时间: ${(endTime - startTime).toFixed(2)}ms`);
+    }
+    catch (error) {
+        errors.push({
+            item: 'handleAppDirectories',
+            type: 'directorySync',
+            error: error,
+            level: 4,
+        });
+    }
+};
 /**
  * 辅助函数：从路径项中提取索引
  * @param pathItem - 路径项，如 'entities[0]'
@@ -556,12 +1222,12 @@ const applyBatchActions = (app, batchActions) => {
         }
     }
     app.emit('collect:end');
-    return new Promise((resolve, reject) => {
-        app.on('save-nasl-success', resolve);
-        app.on('save-nasl-error', (error) => {
-            reject(error);
-        });
-    });
+    // return new Promise((resolve, reject) => {
+    //   app.on('save-nasl-success', resolve);
+    //   app.on('save-nasl-error', (error: any) => {
+    //     reject(error);
+    //   });
+    // });
 };
 exports.applyBatchActions = applyBatchActions;
 //# sourceMappingURL=transform2BatchActions.js.map