@hadss/turbo-trans-json-plugin 1.0.0-rc.0

package/src/json-plugin/JSONExecuteController.ts

@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { HvigorNode } from '@ohos/hvigor';
+import { OhosHapContext, Target } from '@ohos/hvigor-ohos-plugin';
+import { ITask, Logger, TurboTransJsonPluginOptions, ConfigManager, TempSerializerGenerator } from '../core';
+import { TargetContextImpl } from './interfaces/impl/TargetContext';
+import { ModuleContextImpl } from './interfaces/impl/ModuleContext';
+import { IModuleContext } from './interfaces/IModuleContext';
+import { CodeProcessingTask } from './tasks/CodeProcessingTask';
+import { CleanTask } from './tasks/CleanTask';
+import { SyncTask } from './tasks/SyncTask';
+import { WatchTask } from './tasks/WatchTask';
+import SerializationPathUtil from '../core/utils/SerializationPathUtil';
+import { CustomError, ErrorCodes } from '../core/utils/CustomError';
+import { TaskConstants } from './constants/TaskConstants';
+import { TsMorphUtil } from '../core/utils/TsMorphUtil';
+import { CustomTypeAnalyzer } from '../core/analyzers/CustomTypeAnalyzer';
+import { SendableMergeabilityRegistry } from '../core/analyzers/SendableMergeabilityRegistry';
+
+export class JSONExecuteController {
+  private readonly node: HvigorNode;
+  private readonly options: TurboTransJsonPluginOptions;
+  tasks: Set<ITask> = new Set();
+
+  constructor(node: HvigorNode, options: TurboTransJsonPluginOptions) {
+    this.node = node;
+    this.options = options;
+  }
+
+  execute(): void {
+    // 设置导入重写配置
+    const configManager = ConfigManager.getInstance();
+    configManager.setConfig(this.options);
+
+    // 在nodesEvaluated之后才能拿到moduleContext
+    const moduleContext: OhosHapContext = this.node.getContext(this.node.getAllPluginIds()[0]);
+
+    const context = new ModuleContextImpl(this.node, moduleContext);
+
+    context.initScanFiles(this.options.scanDir);
+
+    // 1. 初始化任务
+    this.initTasks();
+
+    // 2. 按照target注册任务
+    moduleContext.targets((target: Target) => {
+      this.registerHvigorTasks(target, context);
+    });
+  }
+
+  compile(): void {
+    // 编译结束后的清理逻辑由clean任务处理
+  }
+
+  private initTasks() {
+    this.tasks.add(new CodeProcessingTask());
+    this.tasks.add(new CleanTask());
+    this.tasks.add(new SyncTask());
+    this.tasks.add(new WatchTask());
+  }
+
+  private taskCleanUp(): void {
+    const sourceFiles = TsMorphUtil.getProject().getSourceFiles();
+    Logger.info(`code analysis Clearing ${sourceFiles.length} source files...`);
+    sourceFiles.forEach((sourceFile) => {
+      TsMorphUtil.getProject().removeSourceFile(sourceFile);
+    });
+    CustomTypeAnalyzer.getInstance().clearCache();
+    SendableMergeabilityRegistry.clear();
+  }
+
+  private registerHvigorTasks(target: Target, context: IModuleContext) {
+    const targetContext = new TargetContextImpl(target, context);
+    this.tasks.forEach((task) => {
+      this.node.registerTask({
+        name: task.taskName,
+        run: async () => {
+          try {
+            Logger.info(`${task.taskName} run`);
+            TempSerializerGenerator.getInstance().init(targetContext);
+            const result = task.run(targetContext);
+            // clean任务不需要生成序列化器
+            if (task.taskName !== TaskConstants.CLEAN_TASK) {
+              TempSerializerGenerator.getInstance().saveFile();
+            }
+            if (result instanceof Promise) {
+              await result;
+            }
+            if (task.taskName === TaskConstants.SYNC_TASK || task.taskName === TaskConstants.CODE_PROCESSING_TASK) {
+              this.taskCleanUp();
+            }
+            Logger.info(`${task.taskName} end`);
+          } catch (error) {
+            if (error instanceof CustomError) {
+              Logger.error(`Error: ${error.constructor.name}: ${error.code} ${error.message}\n${error.stack}`);
+            } else {
+              const err = error as Error;
+              Logger.error(`Error: ${err.constructor.name}: ${ErrorCodes.INTERNAL_ERROR} ${err.message}\n${err.stack}`);
+            }
+            this.taskCleanUp();
+            throw new Error('serialization execute failed');
+          }
+        },
+        dependencies: task.dependencies.map((dep) => `${target.getTargetName()}@${dep}`),
+        postDependencies: task.postDependencies.map((dep) => `${target.getTargetName()}@${dep}`)
+      });
+    });
+
+    const cleanTask = this.node.getTaskByName('clean');
+    if (cleanTask) {
+      cleanTask.beforeRun(() => {
+        const generatedRootDir = targetContext.getOutputRoot();
+
+        if (SerializationPathUtil.exist(generatedRootDir)) {
+          Logger.info(`Clean up the generated directory: ${generatedRootDir}`);
+          SerializationPathUtil.rmSync(generatedRootDir, { recursive: true, force: true });
+        }
+      });
+    }
+  }
+}

package/src/json-plugin/constants/TaskConstants.ts

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+export class TaskConstants {
+  static readonly SYNC_TASK = 'jsonSync';
+  static readonly CLEAN_TASK = 'jsonClean';
+  static readonly WATCH_TASK = 'jsonWatch';
+  static readonly CODE_PROCESSING_TASK = 'SerializationTask';
+  static readonly PRE_BUILD_TASK = 'PreBuild';
+}

package/src/json-plugin/interfaces/IModuleContext.ts

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { HvigorNode } from '@ohos/hvigor'
+import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile'
+import { OhosModuleContext } from '@ohos/hvigor-ohos-plugin/src/plugin/context/plugin-context'
+
+export interface IModuleContext {
+  readonly node: HvigorNode
+  readonly moduleContext: OhosModuleContext
+  readonly buildProfileOpt: ModuleBuildProfile.ModuleBuildOpt
+  readonly scanFiles: string[]
+
+  initScanFiles(scanDir: string[]): void
+}

package/src/json-plugin/interfaces/ITargetContext.ts

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Target } from '@ohos/hvigor-ohos-plugin'
+import { IModuleContext } from './IModuleContext'
+import { ITaskContext } from '../../core'
+
+export interface ITargetContext extends ITaskContext {
+  readonly target: Target
+  readonly context: IModuleContext
+
+  getCurrentTargetScanFiles(): string[]
+}

package/src/json-plugin/interfaces/impl/ModuleContext.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { HvigorNode } from '@ohos/hvigor'
+import { IModuleContext } from '../IModuleContext'
+import SerializationPathUtil from '../../../core/utils/SerializationPathUtil';
+import { OhosHapContext } from '@ohos/hvigor-ohos-plugin';
+import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile';
+
+export class ModuleContextImpl implements IModuleContext {
+  readonly node: HvigorNode
+  readonly moduleContext: OhosHapContext
+  readonly scanFiles: string[] = []
+
+  constructor(node: HvigorNode, moduleContext: OhosHapContext) {
+    this.node = node
+    this.moduleContext = moduleContext
+  }
+
+  /**
+   * 获取模块的buildProfile配置
+   */
+  get buildProfileOpt(): ModuleBuildProfile.ModuleBuildOpt {
+    return this.moduleContext.getBuildProfileOpt();
+  }
+
+  initScanFiles(scanDir: string[]): void {
+    scanDir.forEach(dir => {
+      const scanPath = SerializationPathUtil.pathResolve(this.moduleContext.getModulePath(), dir)
+      this.scanFiles.push(...SerializationPathUtil.scanEtsFiles(scanPath))
+    })
+  }
+}

package/src/json-plugin/interfaces/impl/TargetContext.ts

@@ -0,0 +1,196 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Target } from '@ohos/hvigor-ohos-plugin'
+import { ModuleBuildProfile } from '@ohos/hvigor-ohos-plugin/src/options/build/module-build-profile'
+import { PathConstants} from '../../../core';
+import { IModuleContext } from '../IModuleContext'
+import { ITargetContext } from '../ITargetContext'
+import SerializationPathUtil from '../../../core/utils/SerializationPathUtil';
+import { CustomError, ErrorCodes } from '../../../core/utils/CustomError';
+
+export class TargetContextImpl implements ITargetContext {
+  readonly target: Target
+  readonly context: IModuleContext
+
+  private readonly DEFAULT_SOURCE_ROOT = PathConstants.DEFAULT_SOURCE_ROOT
+  private readonly GENERATED_ROOT = PathConstants.GENERATED_ROOT
+
+  constructor(target: Target, context: IModuleContext) {
+    this.target = target
+    this.context = context
+  }
+
+  private get targetOpt(): ModuleBuildProfile.ModuleTargetBuildOpt {
+    return this.context.buildProfileOpt.targets?.find(
+      (item: ModuleBuildProfile.ModuleTargetBuildOpt) => item.name === this.target.getTargetName())!;
+  }
+
+  /**
+   * 获取当前目标的扫描文件
+   * 从所有扫描文件中筛选出属于当前目标源代码根目录的文件
+   *
+   * @returns 当前目标的扫描文件路径数组，只包含属于当前目标源代码根目录的文件
+   */
+  getCurrentTargetScanFiles(): string[] {
+    // 获取当前目标的所有源代码根目录的绝对路径
+    const absoluteSourceRoots = this.getAbsoluteSourceRoots()
+
+    // 过滤扫描文件，只保留在当前目标源代码根目录下的文件
+    return this.context.scanFiles.filter(item => {
+      // 标准化文件路径格式，确保路径分隔符统一
+      const normalizedFilePath = SerializationPathUtil.normalize(item)
+
+      // 检查文件路径是否以任一源代码根目录开头
+      // 这样可以确保只处理属于当前目标的文件
+      return absoluteSourceRoots.some(sourceRoot => normalizedFilePath.startsWith(sourceRoot))
+    })
+  }
+
+  getModuleName(): string {
+    return this.context.moduleContext.getModuleName()
+  }
+
+  getModulePath(): string {
+    return this.context.moduleContext.getModulePath();
+  }
+
+  getPackageName(): string {
+    // 这里需要获取oh-package.json5中配置的name
+    const packagePath = SerializationPathUtil.pathResolve(this.getModulePath(), 'oh-package.json5')
+    const ohPackageObj = SerializationPathUtil.readJson5(packagePath)
+    return ohPackageObj.name
+  }
+
+  mapToOutputPath(absSourceFile: string): string {
+    const normalizedFilePath = SerializationPathUtil.normalize(absSourceFile)
+    const moduleRoot = this.context.moduleContext.getModulePath()
+    const srcMainAbs = SerializationPathUtil.normalize(SerializationPathUtil.pathResolve(moduleRoot, this.DEFAULT_SOURCE_ROOT))
+    const generatedRootAbs = this.getOutputRoot()
+
+    // 优先基于 src/main 做路径映射
+    if (normalizedFilePath.startsWith(srcMainAbs + SerializationPathUtil.sep)) {
+      const relativeToSrcMain = SerializationPathUtil.relative(srcMainAbs, normalizedFilePath)
+      return SerializationPathUtil.join(generatedRootAbs, relativeToSrcMain)
+    }
+
+    // 如果文件不在 src/main 下，退化为：找到匹配的任一 sourceRoot，映射到 generated 根下
+    const absoluteSourceRoots = this.getAbsoluteSourceRoots()
+    const matchedRoot = absoluteSourceRoots.find(root => normalizedFilePath.startsWith(root))
+    if (matchedRoot) {
+      const rel = SerializationPathUtil.relative(matchedRoot, normalizedFilePath)
+      return SerializationPathUtil.join(generatedRootAbs, rel)
+    }
+
+    // 否则直接放在 generated 根下，保持文件名
+    return SerializationPathUtil.join(generatedRootAbs, SerializationPathUtil.basename(normalizedFilePath))
+  }
+
+  getOutputRoot(): string {
+    const moduleRoot = this.context.moduleContext.getModulePath()
+    const absolutePath = SerializationPathUtil.pathResolve(moduleRoot, this.GENERATED_ROOT)
+    return SerializationPathUtil.normalize(absolutePath)
+  }
+
+  getRelativePath(absolutePath: string): string {
+    const outputRoot = this.getOutputRoot()
+    // 从输出根目录推断项目根目录
+    // 假设输出根目录为: <module>/src/generated
+    const moduleRoot = SerializationPathUtil.dirname(SerializationPathUtil.dirname(outputRoot))
+
+    try {
+      return SerializationPathUtil.relative(moduleRoot, absolutePath).replaceAll(SerializationPathUtil.sep, '/')
+    } catch (error) {
+      // 如果相对路径计算失败，返回原路径
+      return absolutePath
+    }
+  }
+
+  isValidOutputPath(outputPath: string): boolean {
+    try {
+      const outputRoot = this.getOutputRoot()
+      const resolvedOutputPath = SerializationPathUtil.pathResolve(outputPath)
+      const resolvedOutputRoot = SerializationPathUtil.pathResolve(outputRoot)
+
+      // 检查输出路径是否在输出根目录下
+      return resolvedOutputPath.startsWith(resolvedOutputRoot)
+    } catch (error) {
+      return false
+    }
+  }
+
+  ensureOutputDirectory(outputPath: string): void {
+    SerializationPathUtil.ensureDirSync(SerializationPathUtil.dirname(outputPath))
+  }
+
+  calculateSourceRootToModuleRoot(absolutePath: string): string {
+    // 处理Windows环境路径兼容性
+    const normalizedAbsolutePath = absolutePath.replaceAll(SerializationPathUtil.sep, '/')
+
+    // 获取所有源根路径并标准化为统一格式（以 / 结尾）
+    const sourceRoots = this.getAbsoluteSourceRoots().map(root =>
+      root.replaceAll(SerializationPathUtil.sep, '/').replace(/\/$/, '') + '/'
+    )
+
+    // 找到匹配的源根路径
+    const sourceRoot = sourceRoots.find(root => normalizedAbsolutePath.startsWith(root))
+
+    if (!sourceRoot) {
+      throw new CustomError(`无法找到匹配的源根路径: ${normalizedAbsolutePath}。可用的源根路径: ${sourceRoots.join(', ')}`, ErrorCodes.ROOT_DIRECTROY_NOT_FOUND)
+    }
+
+    // 计算相对路径，移除源根路径的尾部分隔符进行计算
+    const sourceRootForRelative = sourceRoot.replace(/\/$/, '')
+    const absolutePathForRelative = normalizedAbsolutePath.replace(/\/$/, '')
+
+    return SerializationPathUtil.relative(sourceRootForRelative, absolutePathForRelative).replaceAll(SerializationPathUtil.sep, '/')
+  }
+
+  private get targetSourceRoots(): string[] {
+    if (!this.targetOpt.source?.sourceRoots) {
+      return [this.DEFAULT_SOURCE_ROOT]
+    }
+    // 检查默认路径是否已包含在sourceRoots中
+    if (!this.targetOpt.source.sourceRoots.includes(this.DEFAULT_SOURCE_ROOT)) {
+      return [this.DEFAULT_SOURCE_ROOT, ...this.targetOpt.source.sourceRoots]
+    }
+    return this.targetOpt.source.sourceRoots
+  }
+
+  /**
+   * 获取当前目标的源代码根目录的绝对路径
+   * 将配置的相对路径源代码根目录转换为标准化的绝对路径
+   *
+   * @returns 标准化的绝对路径数组，每个路径都以路径分隔符结尾
+   */
+  private getAbsoluteSourceRoots(): string[] {
+    // 获取当前模块的根目录路径
+    const moduleRoot = this.context.moduleContext.getModulePath()
+
+    // 将每个相对路径源代码根目录转换为绝对路径
+    return this.targetSourceRoots.map((sourceRoot: string) => {
+      // 将相对路径解析为基于模块根目录的绝对路径
+      // path.resolve 会处理相对路径符号（如 ../ ./）
+      const absolutePath = SerializationPathUtil.pathResolve(moduleRoot, sourceRoot)
+
+      // 标准化路径格式，确保路径分隔符统一，处理多余的分隔符
+      const normalizedPath = SerializationPathUtil.normalize(absolutePath)
+
+      // 确保路径以分隔符结尾，避免路径匹配错误
+      // 例如：/project/src 不会错误匹配 /project/src2
+      return normalizedPath.endsWith(SerializationPathUtil.sep) ? normalizedPath : normalizedPath + SerializationPathUtil.sep
+    })
+  }
+}

package/src/json-plugin/tasks/BaseTask.ts

@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ITask, Logger, ImportRewriteServiceImpl, ConfigManager, CodeGenerationEngine } from '../../core';
+import { BuildProfileUpdaterImpl } from '../../core/import-rewrite/services/BuildProfileUpdater';
+import { ITargetContext } from '../interfaces/ITargetContext';
+import {logger} from 'handlebars';
+import {TaskConstants} from '../constants/TaskConstants';
+import SerializationPathUtil from '../../core/utils/SerializationPathUtil';
+
+export abstract class BaseTask implements ITask {
+  abstract readonly taskName: string;
+  abstract readonly dependencies: string[];
+  abstract readonly postDependencies: string[];
+
+  protected readonly engine = new CodeGenerationEngine();
+  protected readonly buildProfileUpdater = new BuildProfileUpdaterImpl();
+
+  protected getScanFiles(context: ITargetContext): string[] {
+    const scanFiles = context.getCurrentTargetScanFiles();
+
+    if (!scanFiles || scanFiles.length === 0) {
+      Logger.debug('There are no source files to be processed');
+      return [];
+    }
+
+    return scanFiles;
+  }
+
+  protected processWithLogging(scanFiles: string[], context: ITargetContext, taskName: string) {
+    Logger.debug(`Start executing ${taskName} and process ${scanFiles.length} files`);
+
+    this.buildProfileUpdater.updateSourceRoots(context); // 更新builde-profile.json5中的sourceRoot
+
+    const processingResult = this.engine.processFilesUnified(scanFiles, context);
+
+    const totalGenerated = processingResult.generatedFiles.length;
+    const totalSkipped = processingResult.skippedFiles.length;
+
+    Logger.info(`${taskName} completed: generate ${totalGenerated} files and skip ${totalSkipped} files`);
+
+    if (totalGenerated > 0 && taskName === TaskConstants.SYNC_TASK) {
+      const config = context.context.buildProfileOpt;
+      const buildProfilePath = SerializationPathUtil.join(context.getModulePath(), 'build-profile.json5');
+
+      SerializationPathUtil.writeFileSync(buildProfilePath, JSON.stringify(config, null, 2));
+    }
+
+    this.executeImportRewrite(context, taskName);
+    return processingResult;
+  }
+
+  protected executeImportRewrite(context: ITargetContext, taskName: string): void {
+    const configManager = ConfigManager.getInstance();
+
+    Logger.debug(`Start to execute the import rewrite - ${taskName}`);
+
+    // 收集生成文件信息
+    const generatedFileInfos = this.engine.collectGeneratedFileInfos(context);
+
+    if (generatedFileInfos.length === 0) {
+      Logger.debug('No file was generated. Skip the import and rewrite');
+      return;
+    }
+
+    // 获取导入重写配置
+    const importRewriteConfig = configManager.getImportRewriteConfig();
+
+    // 执行导入重写
+    const importRewriteService = new ImportRewriteServiceImpl();
+    importRewriteService.rewriteImports(
+      context,
+      generatedFileInfos,
+      importRewriteConfig
+    );
+
+    Logger.info(`Import and rewrite completed - ${taskName}`);
+  }
+
+  abstract run(context: ITargetContext): void | Promise<void>;
+
+}

package/src/json-plugin/tasks/CleanTask.ts

@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { ITask, Logger } from '../../core';
+import { TaskConstants } from '../constants/TaskConstants';
+import { ITargetContext } from '../interfaces/ITargetContext';
+import SerializationPathUtil from '../../core/utils/SerializationPathUtil';
+
+export class CleanTask implements ITask {
+  readonly taskName: string = TaskConstants.CLEAN_TASK
+  readonly dependencies: string[] = [] // CLI任务无依赖
+  readonly postDependencies: string[] = [] // CLI任务无依赖
+
+  run(context: ITargetContext): void {
+    Logger.info('Start the code cleaning task')
+
+    const generatedRootDir = context.getOutputRoot()
+
+    if (SerializationPathUtil.exist(generatedRootDir)) {
+      Logger.info(`Clean up the generated directory: ${generatedRootDir}`)
+      SerializationPathUtil.rmSync(generatedRootDir, { recursive: true, force: true })
+    }
+  }
+}

package/src/json-plugin/tasks/CodeProcessingTask.ts

@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Logger } from '../../core';
+import { ITargetContext } from '../interfaces/ITargetContext';
+import { TaskConstants } from '../constants/TaskConstants';
+import { BaseTask } from './BaseTask';
+
+export class CodeProcessingTask extends BaseTask {
+  readonly taskName: string = TaskConstants.CODE_PROCESSING_TASK;
+  readonly dependencies: string[] = [];
+  readonly postDependencies: string[] = [TaskConstants.PRE_BUILD_TASK];
+
+  run(context: ITargetContext): void {
+    const scanFiles = this.getScanFiles(context);
+    if (scanFiles.length === 0) {
+      return;
+    }
+
+    const processingResult = this.processWithLogging(scanFiles, context, TaskConstants.CODE_PROCESSING_TASK);
+
+    // 计算包含@Serializable类的文件统计
+    const serializableClassCount = processingResult.generatedFiles.reduce((sum, file) => {
+      return sum + (file.serializerCount || 0);
+    }, 0);
+
+    Logger.info(`Discovered @Serializable classes: ${serializableClassCount}`);
+  }
+}

package/src/json-plugin/tasks/SyncTask.ts

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { TaskConstants } from '../constants/TaskConstants';
+import { ITargetContext } from '../interfaces/ITargetContext';
+import { BaseTask } from './BaseTask';
+
+export class SyncTask extends BaseTask {
+  readonly taskName: string = TaskConstants.SYNC_TASK;
+  readonly dependencies: string[] = []; // CLI任务无依赖
+  readonly postDependencies: string[] = []; // CLI任务无依赖
+
+  run(context: ITargetContext): void {
+    const scanFiles = this.getScanFiles(context);
+    if (scanFiles.length === 0) {
+      return;
+    }
+
+    this.processWithLogging(scanFiles, context, TaskConstants.SYNC_TASK);
+  }
+}