@lark-apaas/fullstack-cli 1.1.6-alpha.10 → 1.1.6-alpha.11

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import fs15 from "fs";
+import fs14 from "fs";
 import path14 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { config as dotenvConfig } from "dotenv";
@@ -1385,39 +1385,55 @@ import path9 from "path";
 var DEFAULT_PLUGIN_VERSION = "1.0.0";
 var PLUGIN_MAPPING = {
   // 飞书相关
-  "official_feishu/send_message": {
-    pluginKey: "@official-plugins/send-feishu-message",
-    pluginVersion: "1.0.0"
+  "@official-plugins/send-feishu-message": {
+    sourceActionID: "official_feishu/send_message",
+    pluginVersion: "1.0.0",
+    actionName: "send_feishu_message"
   },
-  "official_feishu/create_group": {
-    pluginKey: "@official-plugins/feishu-group-create",
-    pluginVersion: "1.0.0"
+  "@official-plugins/feishu-group-create": {
+    sourceActionID: "official_feishu/create_group",
+    pluginVersion: "1.0.0",
+    actionName: "createGroup"
   },
   // AI 相关
-  "official_ai/text_generate": {
-    pluginKey: "@official-plugins/ai-text-generate",
-    pluginVersion: "1.0.0"
+  "@official-plugins/ai-text-generate": {
+    sourceActionID: "official_ai/text_generate",
+    pluginVersion: "1.0.0",
+    actionName: "text_generate"
   },
-  "official_ai/image_understanding": {
-    pluginKey: "@official-plugins/ai-image-understanding",
-    pluginVersion: "1.0.0"
+  "@official-plugins/ai-image-understanding": {
+    sourceActionID: "official_ai/image_understanding",
+    pluginVersion: "1.0.0",
+    actionName: "imageUnderstanding"
   },
-  "official_ai/image_generate": {
-    pluginKey: "@official-plugins/ai-text-to-image",
-    pluginVersion: "1.0.0"
+  "@official-plugins/ai-text-to-image": {
+    sourceActionID: "official_ai/image_generate",
+    pluginVersion: "1.0.0",
+    actionName: "textToImage"
   }
 };
-function getPluginInfo(sourceActionID) {
-  const item = PLUGIN_MAPPING[sourceActionID];
+function getPluginInfoBySourceActionID(sourceActionID) {
+  for (const [pluginKey, item] of Object.entries(PLUGIN_MAPPING)) {
+    if (item.sourceActionID === sourceActionID) {
+      return {
+        pluginKey,
+        pluginVersion: item.pluginVersion ?? DEFAULT_PLUGIN_VERSION,
+        actionName: item.actionName
+      };
+    }
+  }
+  throw new Error(
+    `Unknown sourceActionID: "${sourceActionID}". This sourceActionID is not in the built-in mapping. Please contact the developer to add it.`
+  );
+}
+function getActionNameByPluginKey(pluginKey) {
+  const item = PLUGIN_MAPPING[pluginKey];
   if (!item) {
     throw new Error(
-      `Unknown sourceActionID: "${sourceActionID}". This sourceActionID is not in the built-in mapping. Please contact the developer to add it.`
+      `Unknown pluginKey: "${pluginKey}". This pluginKey is not in the built-in mapping. Please contact the developer to add it.`
     );
   }
-  return {
-    pluginKey: item.pluginKey,
-    pluginVersion: item.pluginVersion ?? DEFAULT_PLUGIN_VERSION
-  };
+  return item.actionName;
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/form-value-transformers/capabilities/send-feishu-message.ts
@@ -1536,7 +1552,7 @@ function transformFormValue(sourceActionID, actionInput) {
 
 // src/commands/migration/versions/v001_capability/json-migrator/transformer.ts
 function transformCapability(old) {
-  const { pluginKey, pluginVersion } = getPluginInfo(old.sourceActionID);
+  const { pluginKey, pluginVersion } = getPluginInfoBySourceActionID(old.sourceActionID);
   const formValue = transformFormValue(old.sourceActionID, old.actionInput);
   return {
     id: old.id,
@@ -1555,15 +1571,39 @@ function transformCapabilities(oldCapabilities) {
 }
 
 // src/commands/migration/versions/v001_capability/json-migrator/index.ts
+function loadExistingCapabilities() {
+  const capabilitiesDir = getCapabilitiesDir2();
+  if (!fs9.existsSync(capabilitiesDir)) {
+    return [];
+  }
+  const files = fs9.readdirSync(capabilitiesDir);
+  const capabilities = [];
+  for (const file of files) {
+    if (file === "capabilities.json" || !file.endsWith(".json")) {
+      continue;
+    }
+    try {
+      const filePath = path9.join(capabilitiesDir, file);
+      const content = fs9.readFileSync(filePath, "utf-8");
+      const capability = JSON.parse(content);
+      if (capability.id && capability.pluginKey) {
+        capabilities.push(capability);
+      }
+    } catch {
+    }
+  }
+  return capabilities;
+}
 async function migrateJsonFiles(options) {
   const detection = detectJsonMigration();
   if (!detection.needsMigration) {
+    const existingCapabilities = loadExistingCapabilities();
     return {
       success: true,
       skipped: true,
       reason: detection.reason,
-      count: 0,
-      capabilities: []
+      count: existingCapabilities.length,
+      capabilities: existingCapabilities
     };
   }
   const { oldCapabilities, oldFilePath } = detection;
@@ -1695,9 +1735,8 @@ async function installPlugins(capabilities, options) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-import fs12 from "fs";
 import path11 from "path";
-import * as ts4 from "typescript";
+import { Project } from "ts-morph";
 
 // src/commands/migration/versions/v001_capability/code-migrator/scanner.ts
 import fs11 from "fs";
@@ -1750,177 +1789,153 @@ function scanFilesToMigrate() {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/analyzers/import-analyzer.ts
-import * as ts from "typescript";
 function extractCapabilityId(importPath) {
   const match = importPath.match(/capabilities\/([^/]+)$/);
-  if (match) {
-    return match[1];
-  }
-  return null;
+  return match ? match[1] : null;
 }
 function isCapabilityImport(importPath) {
   return importPath.includes("capabilities/") || importPath.includes("capabilities\\");
 }
 function analyzeImports(sourceFile) {
   const imports = [];
-  function visit(node) {
-    if (ts.isImportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier;
-      if (ts.isStringLiteral(moduleSpecifier)) {
-        const importPath = moduleSpecifier.text;
-        if (isCapabilityImport(importPath)) {
-          const capabilityId = extractCapabilityId(importPath);
-          if (capabilityId && node.importClause) {
-            const importClause = node.importClause;
-            let importName = null;
-            if (importClause.namedBindings && ts.isNamedImports(importClause.namedBindings)) {
-              for (const element of importClause.namedBindings.elements) {
-                importName = element.name.text;
-                imports.push({
-                  importName,
-                  capabilityId,
-                  start: node.getStart(),
-                  end: node.getEnd(),
-                  text: node.getText()
-                });
-              }
-            } else if (importClause.namedBindings && ts.isNamespaceImport(importClause.namedBindings)) {
-              importName = importClause.namedBindings.name.text;
-              imports.push({
-                importName,
-                capabilityId,
-                start: node.getStart(),
-                end: node.getEnd(),
-                text: node.getText()
-              });
-            } else if (importClause.name) {
-              importName = importClause.name.text;
-              imports.push({
-                importName,
-                capabilityId,
-                start: node.getStart(),
-                end: node.getEnd(),
-                text: node.getText()
-              });
-            }
-          }
-        }
-      }
+  const importDeclarations = sourceFile.getImportDeclarations();
+  for (const importDecl of importDeclarations) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (!isCapabilityImport(moduleSpecifier)) {
+      continue;
+    }
+    const capabilityId = extractCapabilityId(moduleSpecifier);
+    if (!capabilityId) {
+      continue;
+    }
+    const namedImports = importDecl.getNamedImports();
+    for (const namedImport of namedImports) {
+      const importName = namedImport.getAliasNode()?.getText() || namedImport.getName();
+      imports.push({
+        importName,
+        capabilityId,
+        start: importDecl.getStart(),
+        end: importDecl.getEnd(),
+        text: importDecl.getText()
+      });
+    }
+    const namespaceImport = importDecl.getNamespaceImport();
+    if (namespaceImport) {
+      imports.push({
+        importName: namespaceImport.getText(),
+        capabilityId,
+        start: importDecl.getStart(),
+        end: importDecl.getEnd(),
+        text: importDecl.getText()
+      });
+    }
+    const defaultImport = importDecl.getDefaultImport();
+    if (defaultImport) {
+      imports.push({
+        importName: defaultImport.getText(),
+        capabilityId,
+        start: importDecl.getStart(),
+        end: importDecl.getEnd(),
+        text: importDecl.getText()
+      });
     }
-    ts.forEachChild(node, visit);
   }
-  visit(sourceFile);
   return imports;
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/analyzers/call-site-analyzer.ts
-import * as ts2 from "typescript";
+import { SyntaxKind } from "ts-morph";
 function analyzeCallSites(sourceFile, imports) {
   const callSites = [];
   const importMap = /* @__PURE__ */ new Map();
   for (const imp of imports) {
     importMap.set(imp.importName, imp.capabilityId);
   }
-  function visit(node) {
-    if (ts2.isCallExpression(node)) {
-      const expression = node.expression;
-      if (ts2.isIdentifier(expression)) {
-        const functionName = expression.text;
-        const capabilityId = importMap.get(functionName);
-        if (capabilityId) {
-          const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
-          callSites.push({
-            functionName,
-            capabilityId,
-            start: node.getStart(),
-            end: node.getEnd(),
-            line: line + 1,
-            // 转为 1-based
-            text: node.getText()
-          });
-        }
-      } else if (ts2.isPropertyAccessExpression(expression)) {
-        const objectName = expression.expression;
-        if (ts2.isIdentifier(objectName)) {
-          const capabilityId = importMap.get(objectName.text);
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind.CallExpression);
+  for (const callExpr of callExpressions) {
+    const expression = callExpr.getExpression();
+    if (expression.getKind() === SyntaxKind.Identifier) {
+      const functionName = expression.getText();
+      const capabilityId = importMap.get(functionName);
+      if (capabilityId) {
+        callSites.push({
+          functionName,
+          capabilityId,
+          start: callExpr.getStart(),
+          end: callExpr.getEnd(),
+          line: callExpr.getStartLineNumber(),
+          text: callExpr.getText()
+        });
+      }
+    } else if (expression.getKind() === SyntaxKind.PropertyAccessExpression) {
+      const propAccess = expression.asKind(SyntaxKind.PropertyAccessExpression);
+      if (propAccess) {
+        const objectExpr = propAccess.getExpression();
+        if (objectExpr.getKind() === SyntaxKind.Identifier) {
+          const objectName = objectExpr.getText();
+          const capabilityId = importMap.get(objectName);
           if (capabilityId) {
-            const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
             callSites.push({
-              functionName: `${objectName.text}.${expression.name.text}`,
+              functionName: `${objectName}.${propAccess.getName()}`,
               capabilityId,
-              start: node.getStart(),
-              end: node.getEnd(),
-              line: line + 1,
-              text: node.getText()
+              start: callExpr.getStart(),
+              end: callExpr.getEnd(),
+              line: callExpr.getStartLineNumber(),
+              text: callExpr.getText()
             });
           }
         }
       }
     }
-    ts2.forEachChild(node, visit);
   }
-  visit(sourceFile);
   return callSites;
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/analyzers/class-analyzer.ts
-import * as ts3 from "typescript";
-function hasDecorator(node, decoratorName) {
-  const decorators = ts3.getDecorators(node);
-  if (!decorators) {
-    return false;
-  }
+function hasDecorator(classDecl, decoratorName) {
+  const decorators = classDecl.getDecorators();
   return decorators.some((decorator) => {
-    const expression = decorator.expression;
-    if (ts3.isIdentifier(expression)) {
-      return expression.text === decoratorName;
-    }
-    if (ts3.isCallExpression(expression) && ts3.isIdentifier(expression.expression)) {
-      return expression.expression.text === decoratorName;
-    }
-    return false;
+    const name = decorator.getName();
+    return name === decoratorName;
   });
 }
 function analyzeClass(sourceFile) {
+  const classes = sourceFile.getClasses();
   let classInfo;
-  function visit(node) {
-    if (ts3.isClassDeclaration(node) && node.name) {
-      const isInjectable = hasDecorator(node, "Injectable");
-      const isController = hasDecorator(node, "Controller");
-      if (classInfo && classInfo.isInjectable && !isInjectable && !isController) {
-        return;
-      }
-      const info = {
-        name: node.name.text,
-        isInjectable,
-        isController,
-        constructorParamCount: 0
-      };
-      for (const member of node.members) {
-        if (ts3.isConstructorDeclaration(member)) {
-          info.constructorParamCount = member.parameters.length;
-          info.constructorStart = member.getStart();
-          info.constructorEnd = member.getEnd();
-          if (member.parameters.length > 0) {
-            const lastParam = member.parameters[member.parameters.length - 1];
-            info.constructorParamsEnd = lastParam.getEnd();
-          } else {
-            const constructorText = member.getText();
-            const parenIndex = constructorText.indexOf("(");
-            if (parenIndex !== -1) {
-              info.constructorParamsEnd = member.getStart() + parenIndex + 1;
-            }
-          }
-          break;
-        }
-      }
-      if (isInjectable || isController || !classInfo) {
-        classInfo = info;
+  for (const classDecl of classes) {
+    const name = classDecl.getName();
+    if (!name) continue;
+    const isInjectable = hasDecorator(classDecl, "Injectable");
+    const isController = hasDecorator(classDecl, "Controller");
+    if (classInfo && classInfo.isInjectable && !isInjectable && !isController) {
+      continue;
+    }
+    const info = {
+      name,
+      isInjectable,
+      isController,
+      constructorParamCount: 0
+    };
+    const classBody = classDecl.getChildSyntaxListOrThrow();
+    info.classBodyStart = classBody.getStart();
+    const constructors = classDecl.getConstructors();
+    if (constructors.length > 0) {
+      const ctor = constructors[0];
+      info.constructorParamCount = ctor.getParameters().length;
+      info.constructorStart = ctor.getStart();
+      info.constructorEnd = ctor.getEnd();
+      const params = ctor.getParameters();
+      if (params.length > 0) {
+        const lastParam = params[params.length - 1];
+        info.constructorParamsEnd = lastParam.getEnd();
+      } else {
+        info.constructorParamsEnd = ctor.getStart();
       }
     }
-    ts3.forEachChild(node, visit);
+    if (isInjectable || isController || !classInfo) {
+      classInfo = info;
+    }
   }
-  visit(sourceFile);
   return classInfo;
 }
 function canAutoMigrate(classInfo) {
@@ -1940,128 +1955,203 @@ function canAutoMigrate(classInfo) {
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/transformers/import-transformer.ts
-var CAPABILITY_SERVICE_IMPORT = `import { CapabilityService, migrationAdaptor } from '@lark-apaas/fullstack-nestjs-core';`;
-var INJECT_IMPORT = `import { Inject } from '@nestjs/common';`;
-function hasCapabilityServiceImport(content) {
-  return /import\s+.*CapabilityService.*from\s+['"]@lark-apaas\/fullstack-nestjs-core['"]/.test(content);
-}
-function hasInjectImport(content) {
-  return /import\s+.*\bInject\b.*from\s+['"]@nestjs\/common['"]/.test(content);
-}
-function findImportInsertPosition(content) {
-  const importRegex = /^import\s+.*?from\s+['"][^'"]+['"];?\s*$/gm;
-  let lastMatch = null;
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    lastMatch = match;
-  }
-  if (lastMatch) {
-    return lastMatch.index + lastMatch[0].length;
-  }
-  return 0;
-}
-function transformImports(content, imports) {
-  const sortedImports = [...imports].sort((a, b) => b.start - a.start);
-  let result = content;
-  for (const imp of sortedImports) {
-    const before = result.substring(0, imp.start);
-    const after = result.substring(imp.end);
-    const trimmedAfter = after.replace(/^\r?\n/, "");
-    result = before + trimmedAfter;
+var CORE_MODULE = "@lark-apaas/fullstack-nestjs-core";
+var NESTJS_COMMON_MODULE = "@nestjs/common";
+function hasCapabilityServiceImport(sourceFile) {
+  const imports = sourceFile.getImportDeclarations();
+  for (const importDecl of imports) {
+    if (importDecl.getModuleSpecifierValue() === CORE_MODULE) {
+      const namedImports = importDecl.getNamedImports();
+      if (namedImports.some((ni) => ni.getName() === "CapabilityService")) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function hasInjectImport(sourceFile) {
+  const imports = sourceFile.getImportDeclarations();
+  for (const importDecl of imports) {
+    if (importDecl.getModuleSpecifierValue() === NESTJS_COMMON_MODULE) {
+      const namedImports = importDecl.getNamedImports();
+      if (namedImports.some((ni) => ni.getName() === "Inject")) {
+        return true;
+      }
+    }
   }
+  return false;
+}
+function transformImports(sourceFile, capabilityImports) {
   let importAdded = false;
-  if (!hasCapabilityServiceImport(result)) {
-    const insertPos = findImportInsertPosition(result);
-    if (insertPos > 0) {
-      result = result.substring(0, insertPos) + "\n" + CAPABILITY_SERVICE_IMPORT + result.substring(insertPos);
+  let importsRemoved = 0;
+  const importPaths = new Set(capabilityImports.map((imp) => {
+    const match = imp.text.match(/from\s+['"]([^'"]+)['"]/);
+    return match ? match[1] : "";
+  }));
+  const importDeclarations = sourceFile.getImportDeclarations();
+  for (const importDecl of importDeclarations) {
+    const moduleSpecifier = importDecl.getModuleSpecifierValue();
+    if (importPaths.has(moduleSpecifier)) {
+      importDecl.remove();
+      importsRemoved++;
+    }
+  }
+  if (!hasCapabilityServiceImport(sourceFile)) {
+    const existingCoreImport = sourceFile.getImportDeclaration(CORE_MODULE);
+    if (existingCoreImport) {
+      const namedImports = existingCoreImport.getNamedImports();
+      const existingNames = namedImports.map((ni) => ni.getName());
+      if (!existingNames.includes("CapabilityService")) {
+        existingCoreImport.addNamedImport("CapabilityService");
+      }
+      if (!existingNames.includes("migrationAdaptor")) {
+        existingCoreImport.addNamedImport("migrationAdaptor");
+      }
     } else {
-      result = CAPABILITY_SERVICE_IMPORT + "\n" + result;
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: CORE_MODULE,
+        namedImports: ["CapabilityService", "migrationAdaptor"]
+      });
     }
     importAdded = true;
   }
-  if (!hasInjectImport(result)) {
-    const insertPos = findImportInsertPosition(result);
-    if (insertPos > 0) {
-      result = result.substring(0, insertPos) + "\n" + INJECT_IMPORT + result.substring(insertPos);
+  if (!hasInjectImport(sourceFile)) {
+    const existingNestImport = sourceFile.getImportDeclaration(NESTJS_COMMON_MODULE);
+    if (existingNestImport) {
+      const namedImports = existingNestImport.getNamedImports();
+      const existingNames = namedImports.map((ni) => ni.getName());
+      if (!existingNames.includes("Inject")) {
+        existingNestImport.addNamedImport("Inject");
+      }
     } else {
-      result = INJECT_IMPORT + "\n" + result;
+      sourceFile.addImportDeclaration({
+        moduleSpecifier: NESTJS_COMMON_MODULE,
+        namedImports: ["Inject"]
+      });
     }
     importAdded = true;
   }
-  return { content: result, importAdded };
+  return { importAdded, importsRemoved };
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/transformers/injection-transformer.ts
-var INJECTION_PARAM = "@Inject() private readonly capabilityService: CapabilityService";
-function hasCapabilityServiceInjection(content) {
-  return /capabilityService\s*:\s*CapabilityService/.test(content);
-}
-function addInjection(content, classInfo) {
-  if (hasCapabilityServiceInjection(content)) {
-    return { content, injectionAdded: false };
-  }
-  if (classInfo.constructorParamsEnd === void 0) {
-    return { content, injectionAdded: false };
-  }
-  let result = content;
-  const insertPos = classInfo.constructorParamsEnd;
-  if (classInfo.constructorParamCount > 0) {
-    const afterParams = content.substring(insertPos);
-    const beforeParams = content.substring(0, insertPos);
-    result = beforeParams + ",\n    " + INJECTION_PARAM + afterParams;
-  } else {
-    const constructorMatch = content.match(/constructor\s*\(\s*/);
-    if (constructorMatch && constructorMatch.index !== void 0) {
-      const paramStart = constructorMatch.index + constructorMatch[0].length;
-      const before = content.substring(0, paramStart);
-      const after = content.substring(paramStart);
-      result = before + INJECTION_PARAM + after;
+import { Scope } from "ts-morph";
+var PARAM_NAME = "capabilityService";
+var PARAM_TYPE = "CapabilityService";
+function hasCapabilityServiceInjection(sourceFile) {
+  const classes = sourceFile.getClasses();
+  for (const classDecl of classes) {
+    const constructors = classDecl.getConstructors();
+    for (const ctor of constructors) {
+      const params = ctor.getParameters();
+      for (const param of params) {
+        if (param.getName() === PARAM_NAME) {
+          return true;
+        }
+      }
     }
   }
-  return { content: result, injectionAdded: result !== content };
+  return false;
 }
-
-// src/commands/migration/versions/v001_capability/code-migrator/transformers/call-site-transformer.ts
-function generateNewCall(capabilityId, originalCall) {
-  const parenIndex = originalCall.indexOf("(");
-  if (parenIndex === -1) {
-    return originalCall;
-  }
-  const argsStart = parenIndex + 1;
-  const argsEnd = originalCall.lastIndexOf(")");
-  let args = "{}";
-  if (argsEnd !== -1 && argsEnd > argsStart) {
-    const extractedArgs = originalCall.substring(argsStart, argsEnd).trim();
-    if (extractedArgs) {
-      args = extractedArgs;
+function findInjectableClass(sourceFile) {
+  const classes = sourceFile.getClasses();
+  for (const classDecl of classes) {
+    const decorators = classDecl.getDecorators();
+    const isInjectable = decorators.some((d) => d.getName() === "Injectable");
+    const isController = decorators.some((d) => d.getName() === "Controller");
+    if (isInjectable || isController) {
+      return classDecl;
     }
   }
-  return `migrationAdaptor(this.capabilityService.load('${capabilityId}').call('run', ${args}))`;
+  return void 0;
 }
-function transformCallSites(content, callSites) {
-  const sortedCallSites = [...callSites].sort((a, b) => b.start - a.start);
-  let result = content;
+function addInjection(sourceFile) {
+  if (hasCapabilityServiceInjection(sourceFile)) {
+    return { injectionAdded: false };
+  }
+  const classDecl = findInjectableClass(sourceFile);
+  if (!classDecl) {
+    return { injectionAdded: false };
+  }
+  const constructors = classDecl.getConstructors();
+  if (constructors.length > 0) {
+    const ctor = constructors[0];
+    ctor.addParameter({
+      name: PARAM_NAME,
+      type: PARAM_TYPE,
+      scope: Scope.Private,
+      isReadonly: true,
+      decorators: [{ name: "Inject", arguments: [] }]
+    });
+  } else {
+    classDecl.addConstructor({
+      parameters: [{
+        name: PARAM_NAME,
+        type: PARAM_TYPE,
+        scope: Scope.Private,
+        isReadonly: true,
+        decorators: [{ name: "Inject", arguments: [] }]
+      }]
+    });
+  }
+  return { injectionAdded: true };
+}
+
+// src/commands/migration/versions/v001_capability/code-migrator/transformers/call-site-transformer.ts
+import { SyntaxKind as SyntaxKind2 } from "ts-morph";
+var DEFAULT_ACTION_NAME = "run";
+function generateNewCallText(capabilityId, actionName, args) {
+  const argsText = args.trim() || "{}";
+  return `migrationAdaptor(this.capabilityService.load('${capabilityId}').call('${actionName}', ${argsText}))`;
+}
+function transformCallSites(sourceFile, imports) {
+  const importMap = /* @__PURE__ */ new Map();
+  for (const imp of imports) {
+    importMap.set(imp.importName, {
+      capabilityId: imp.capabilityId,
+      actionName: imp.actionName ?? DEFAULT_ACTION_NAME
+    });
+  }
   let replacedCount = 0;
-  for (const callSite of sortedCallSites) {
-    const newCall = generateNewCall(callSite.capabilityId, callSite.text);
-    const before = result.substring(0, callSite.start);
-    const after = result.substring(callSite.end);
-    result = before + newCall + after;
-    replacedCount++;
+  const callExpressions = sourceFile.getDescendantsOfKind(SyntaxKind2.CallExpression);
+  const sortedCalls = [...callExpressions].sort((a, b) => b.getStart() - a.getStart());
+  for (const callExpr of sortedCalls) {
+    const expression = callExpr.getExpression();
+    let importInfo;
+    if (expression.getKind() === SyntaxKind2.Identifier) {
+      const functionName = expression.getText();
+      importInfo = importMap.get(functionName);
+    } else if (expression.getKind() === SyntaxKind2.PropertyAccessExpression) {
+      const propAccess = expression.asKind(SyntaxKind2.PropertyAccessExpression);
+      if (propAccess) {
+        const objectExpr = propAccess.getExpression();
+        if (objectExpr.getKind() === SyntaxKind2.Identifier) {
+          const objectName = objectExpr.getText();
+          importInfo = importMap.get(objectName);
+        }
+      }
+    }
+    if (importInfo) {
+      const args = callExpr.getArguments();
+      const argsText = args.map((arg) => arg.getText()).join(", ");
+      const newCallText = generateNewCallText(importInfo.capabilityId, importInfo.actionName, argsText);
+      callExpr.replaceWithText(newCallText);
+      replacedCount++;
+    }
   }
-  return { content: result, replacedCount };
+  return { replacedCount };
 }
 
 // src/commands/migration/versions/v001_capability/code-migrator/index.ts
-function analyzeFile(filePath) {
-  const content = fs12.readFileSync(filePath, "utf-8");
-  const sourceFile = ts4.createSourceFile(
-    filePath,
-    content,
-    ts4.ScriptTarget.Latest,
-    true
-  );
+function analyzeFile(project, filePath, actionNameMap) {
+  const sourceFile = project.addSourceFileAtPath(filePath);
   const imports = analyzeImports(sourceFile);
+  for (const imp of imports) {
+    const actionName = actionNameMap.get(imp.capabilityId);
+    if (actionName) {
+      imp.actionName = actionName;
+    }
+  }
   const callSites = analyzeCallSites(sourceFile, imports);
   const classInfo = analyzeClass(sourceFile);
   const { canMigrate, reason } = canAutoMigrate(classInfo);
@@ -2075,7 +2165,7 @@ function analyzeFile(filePath) {
     manualMigrationReason: reason
   };
 }
-function migrateFile(analysis, dryRun) {
+function migrateFile(project, analysis, dryRun) {
   const absolutePath = path11.join(getProjectRoot3(), analysis.filePath);
   if (!analysis.canAutoMigrate) {
     return {
@@ -2088,42 +2178,19 @@ function migrateFile(analysis, dryRun) {
     };
   }
   try {
-    let content = fs12.readFileSync(absolutePath, "utf-8");
-    const callResult = transformCallSites(content, analysis.callSites);
-    content = callResult.content;
-    const sourceFile = ts4.createSourceFile(
-      analysis.filePath,
-      content,
-      ts4.ScriptTarget.Latest,
-      true
-    );
-    const newImports = analyzeImports(sourceFile);
-    const importResult = transformImports(content, newImports);
-    content = importResult.content;
-    let injectionAdded = false;
-    if (analysis.classInfo) {
-      const newSourceFile = ts4.createSourceFile(
-        analysis.filePath,
-        content,
-        ts4.ScriptTarget.Latest,
-        true
-      );
-      const newClassInfo = analyzeClass(newSourceFile);
-      if (newClassInfo) {
-        const injectionResult = addInjection(content, newClassInfo);
-        content = injectionResult.content;
-        injectionAdded = injectionResult.injectionAdded;
-      }
-    }
+    const sourceFile = project.getSourceFileOrThrow(absolutePath);
+    const callResult = transformCallSites(sourceFile, analysis.imports);
+    const importResult = transformImports(sourceFile, analysis.imports);
+    const injectionResult = addInjection(sourceFile);
     if (!dryRun) {
-      fs12.writeFileSync(absolutePath, content, "utf-8");
+      sourceFile.saveSync();
     }
     return {
       filePath: analysis.filePath,
       success: true,
-      importsRemoved: analysis.imports.length,
+      importsRemoved: importResult.importsRemoved,
       callSitesReplaced: callResult.replacedCount,
-      injectionAdded
+      injectionAdded: injectionResult.injectionAdded
     };
   } catch (error) {
     return {
@@ -2136,20 +2203,39 @@ function migrateFile(analysis, dryRun) {
     };
   }
 }
-async function migrateCode(options) {
+function buildActionNameMap(capabilities) {
+  const map = /* @__PURE__ */ new Map();
+  for (const cap of capabilities) {
+    try {
+      const actionName = getActionNameByPluginKey(cap.pluginKey);
+      map.set(cap.id, actionName);
+    } catch {
+      map.set(cap.id, "run");
+    }
+  }
+  return map;
+}
+async function migrateCode(options, capabilities) {
   const result = {
     autoMigrated: [],
     manualRequired: []
   };
+  const actionNameMap = buildActionNameMap(capabilities);
   const filesToMigrate = scanFilesToMigrate();
   if (filesToMigrate.length === 0) {
     console.log("   No files need code migration.\n");
     return result;
   }
+  const project = new Project({
+    skipAddingFilesFromTsConfig: true,
+    compilerOptions: {
+      allowJs: true
+    }
+  });
   const analyses = [];
   for (const filePath of filesToMigrate) {
     try {
-      const analysis = analyzeFile(filePath);
+      const analysis = analyzeFile(project, filePath, actionNameMap);
       analyses.push(analysis);
     } catch (error) {
       console.error(`   \u2717 Failed to analyze ${filePath}: ${error}`);
@@ -2167,7 +2253,7 @@ async function migrateCode(options) {
     });
   }
   for (const analysis of autoMigratable) {
-    const migrationResult = migrateFile(analysis, options.dryRun);
+    const migrationResult = migrateFile(project, analysis, options.dryRun);
     result.autoMigrated.push(migrationResult);
   }
   return result;
@@ -2183,17 +2269,17 @@ function getSuggestion(analysis) {
 }
 
 // src/commands/migration/versions/v001_capability/cleanup.ts
-import fs13 from "fs";
+import fs12 from "fs";
 import path12 from "path";
 function cleanupOldFiles(capabilities, dryRun) {
   const deletedFiles = [];
   const errors = [];
   const capabilitiesDir = getCapabilitiesDir2();
   const oldJsonPath = path12.join(capabilitiesDir, "capabilities.json");
-  if (fs13.existsSync(oldJsonPath)) {
+  if (fs12.existsSync(oldJsonPath)) {
     try {
       if (!dryRun) {
-        fs13.unlinkSync(oldJsonPath);
+        fs12.unlinkSync(oldJsonPath);
       }
       deletedFiles.push("capabilities.json");
     } catch (error) {
@@ -2202,10 +2288,10 @@ function cleanupOldFiles(capabilities, dryRun) {
   }
   for (const cap of capabilities) {
     const tsFilePath = path12.join(capabilitiesDir, `${cap.id}.ts`);
-    if (fs13.existsSync(tsFilePath)) {
+    if (fs12.existsSync(tsFilePath)) {
       try {
         if (!dryRun) {
-          fs13.unlinkSync(tsFilePath);
+          fs12.unlinkSync(tsFilePath);
         }
         deletedFiles.push(`${cap.id}.ts`);
       } catch (error) {
@@ -2221,7 +2307,7 @@ function cleanupOldFiles(capabilities, dryRun) {
 }
 
 // src/commands/migration/versions/v001_capability/report-generator.ts
-import fs14 from "fs";
+import fs13 from "fs";
 import path13 from "path";
 var REPORT_FILE = "capability-migration-report.md";
 function printSummary(result) {
@@ -2385,7 +2471,7 @@ async function generateReport(result) {
   }
   lines.push("");
   const reportPath = path13.join(getProjectRoot3(), REPORT_FILE);
-  fs14.writeFileSync(reportPath, lines.join("\n"), "utf-8");
+  fs13.writeFileSync(reportPath, lines.join("\n"), "utf-8");
   console.log(`\u{1F4C4} Report generated: ${REPORT_FILE}`);
 }
 
@@ -2478,7 +2564,7 @@ async function runCapabilityMigration(options = {}) {
   console.log("\u{1F527} Step 3: Code Migration");
   console.log("   Scanning server/ directory...\n");
   try {
-    codeResult = await migrateCode(fullOptions);
+    codeResult = await migrateCode(fullOptions, jsonResult.capabilities);
     let hasCodeError = false;
     for (const file of codeResult.autoMigrated) {
       if (file.success) {
@@ -2904,11 +2990,11 @@ var commands = [
 
 // src/index.ts
 var envPath = path14.join(process.cwd(), ".env");
-if (fs15.existsSync(envPath)) {
+if (fs14.existsSync(envPath)) {
   dotenvConfig({ path: envPath });
 }
 var __dirname = path14.dirname(fileURLToPath3(import.meta.url));
-var pkg = JSON.parse(fs15.readFileSync(path14.join(__dirname, "../package.json"), "utf-8"));
+var pkg = JSON.parse(fs14.readFileSync(path14.join(__dirname, "../package.json"), "utf-8"));
 var cli = new FullstackCLI(pkg.version);
 cli.useAll(commands);
 cli.run();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/fullstack-cli",
-  "version": "1.1.6-alpha.10",
+  "version": "1.1.6-alpha.11",
   "description": "CLI tool for fullstack template management",
   "type": "module",
   "main": "dist/index.js",
@@ -37,6 +37,7 @@
     "commander": "^13.0.0",
     "dotenv": "^16.0.0",
     "drizzle-kit": "0.31.5",
+    "ts-morph": "^27.0.0",
     "zod-to-json-schema": "^3.24.1"
   },
   "devDependencies": {