diff --git a/gofaster/app/plugins/route-mapping-plugin.js b/gofaster/app/plugins/route-mapping-plugin.js
index 24b1e7c..623d659 100644
--- a/gofaster/app/plugins/route-mapping-plugin.js
+++ b/gofaster/app/plugins/route-mapping-plugin.js
@@ -306,7 +306,7 @@ function routeMappingPlugin() {
               const apiCalls = self.extractApiCallsFromFunction(path)
               apiCalls.forEach(apiCall => {
                 apiMappings.push({
-                  methodName: functionName,
+                  apiMethodName: functionName,
                   method: apiCall.method,
                   path: apiCall.path,
                   line: apiCall.line
@@ -324,7 +324,7 @@ function routeMappingPlugin() {
                 const apiCalls = self.extractApiCallsFromFunction(functionPath)
                 apiCalls.forEach(apiCall => {
                   apiMappings.push({
-                    methodName: functionName,
+                    apiMethodName: functionName,
                     method: apiCall.method,
                     path: apiCall.path,
                     line: apiCall.line
@@ -336,12 +336,12 @@ function routeMappingPlugin() {
           
           // 查找对象方法定义
           ObjectMethod(path) {
-            const methodName = path.node.key?.name
-            if (methodName) {
+            const apiMethodName = path.node.key?.name
+            if (apiMethodName) {
               const apiCalls = self.extractApiCallsFromFunction(path)
               apiCalls.forEach(apiCall => {
                 apiMappings.push({
-                  methodName: methodName,
+                  apiMethodName: apiMethodName,
                   method: apiCall.method,
                   path: apiCall.path,
                   line: apiCall.line
@@ -353,12 +353,12 @@ function routeMappingPlugin() {
           // 查找对象属性中的函数
           ObjectProperty(path) {
             if (path.node.value && (path.node.value.type === 'ArrowFunctionExpression' || path.node.value.type === 'FunctionExpression')) {
-              const methodName = path.node.key?.name
-              if (methodName) {
+              const apiMethodName = path.node.key?.name
+              if (apiMethodName) {
                 const apiCalls = self.extractApiCallsFromFunction(path.get('value'))
                 apiCalls.forEach(apiCall => {
                   apiMappings.push({
-                    methodName: methodName,
+                    apiMethodName: apiMethodName,
                     method: apiCall.method,
                     path: apiCall.path,
                     line: apiCall.line
@@ -484,10 +484,10 @@ function routeMappingPlugin() {
             routes, 
             moduleMapping.module, 
             moduleMapping.serviceName, 
-            apiMapping.methodName
+            apiMapping.apiMethodName
           )
           
-          console.log(`🔍 API方法 ${apiMapping.methodName} 的触发器数量:`, triggerSources.length)
+          console.log(`🔍 API方法 ${apiMapping.apiMethodName} 的触发器数量:`, triggerSources.length)
           
           return {
             ...apiMapping,
@@ -506,10 +506,10 @@ function routeMappingPlugin() {
     },
 
     // 查找API方法的触发器源 - 使用简化的方法
-    findTriggerSourcesForApiMethod(routes, moduleName, serviceName, methodName) {
+    findTriggerSourcesForApiMethod(routes, moduleName, serviceName, apiMethodName) {
       const triggerSources = []
       
-      console.log(`🔍 查找API方法 ${serviceName}.${methodName} 的触发器源，模块: ${moduleName}`)
+      console.log(`🔍 查找API方法 ${serviceName}.${apiMethodName} 的触发器源，模块: ${moduleName}`)
       
       // 1. 遍历所有路由，查找调用该API方法的页面组件
       routes.forEach(route => {
@@ -520,7 +520,7 @@ function routeMappingPlugin() {
             route.path, 
             moduleName,
             serviceName,
-            methodName
+            apiMethodName
           )
           
           if (triggerAnalysis && triggerAnalysis.triggerSources.length > 0) {
@@ -541,7 +541,7 @@ function routeMappingPlugin() {
           null, // components目录中的组件没有路由路径
           moduleName,
           serviceName,
-          methodName
+          apiMethodName
         )
         
         if (triggerAnalysis && triggerAnalysis.triggerSources.length > 0) {
@@ -562,16 +562,16 @@ function routeMappingPlugin() {
         }
       })
       
-      console.log(`🔍 API方法 ${serviceName}.${methodName} 最终触发器数量:`, uniqueTriggerSources.length)
+      console.log(`🔍 API方法 ${serviceName}.${apiMethodName} 最终触发器数量:`, uniqueTriggerSources.length)
       return uniqueTriggerSources
     },
 
     // 简化的组件触发器源分析方法
-    analyzeComponentForTriggerSourcesSimple(componentName, componentPath, moduleName, serviceName, methodName) {
+    analyzeComponentForTriggerSourcesSimple(componentName, componentPath, moduleName, serviceName, apiMethodName) {
       try {
         let filePath = componentPath
         
-        console.log(`🔍 简化分析组件 ${componentName}，查找服务 ${serviceName}.${methodName}`)
+        console.log(`🔍 简化分析组件 ${componentName}，查找服务 ${serviceName}.${apiMethodName}`)
         
         // 如果是组件名，需要找到对应的文件
         if (!filePath || !existsSync(filePath)) {
@@ -586,8 +586,8 @@ function routeMappingPlugin() {
         console.log(`🔍 找到组件文件: ${filePath}`)
         const content = readFileSync(filePath, 'utf-8')
         
-        // 使用简化的文本搜索方法
-        return this.analyzeComponentWithTextSearch(content, componentName, serviceName, methodName)
+        // 使用AST分析方法
+        return this.analyzeComponentWithAST(content, componentName, serviceName, apiMethodName, filePath)
         
       } catch (error) {
         console.warn(`⚠️ 简化分析组件触发器源失败: ${componentName}`, error.message)
@@ -595,11 +595,47 @@ function routeMappingPlugin() {
       }
     },
 
-    // 使用文本搜索分析组件
-    analyzeComponentWithTextSearch(content, componentName, serviceName, methodName) {
+    // 生成唯一的按钮名称
+    generateUniqueButtonName(componentName, clickHandler) {
+      // 基于组件名生成简洁的名称
+      const baseName = componentName.toLowerCase()
+      // 添加随机尾缀确保唯一性
+      const randomSuffix = Math.random().toString(36).substring(2, 8)
+      return `${baseName}-${randomSuffix}`
+    },
+
+    // 为按钮添加name属性
+    addNameAttributeToButton(filePath, buttonHtml, generatedName) {
+      try {
+        const fs = require('fs')
+        const content = fs.readFileSync(filePath, 'utf-8')
+        
+        // 检查按钮是否已经有name属性
+        if (buttonHtml.includes('name=')) {
+          console.log(`⚠️ 按钮已有name属性，跳过: ${generatedName}`)
+          return
+        }
+        
+        // 在button标签中添加name属性
+        const updatedButtonHtml = buttonHtml.replace(/<button([^>]*)>/, `<button$1 name="${generatedName}">`)
+        
+        // 替换文件中的按钮HTML
+        const updatedContent = content.replace(buttonHtml, updatedButtonHtml)
+        
+        // 写回文件
+        fs.writeFileSync(filePath, updatedContent, 'utf-8')
+        
+        console.log(`✅ 已为按钮添加name属性: ${generatedName}`)
+      } catch (error) {
+        console.warn(`⚠️ 添加name属性失败: ${error.message}`)
+      }
+    },
+
+    // 使用AST分析组件
+    analyzeComponentWithAST(content, componentName, serviceName, apiMethodName, filePath = null) {
       const triggerSources = []
 
-      console.log(`🔍 文本搜索组件 ${componentName}，查找 ${serviceName}.${methodName}`)
+      console.log(`🔍 AST分析组件 ${componentName}，查找 ${serviceName}.${apiMethodName}`)
 
       // 1. 检查组件的authType属性，如果是public则跳过
       // 支持两种格式：<template authType="public"> 和 authType: 'public'
@@ -614,26 +650,22 @@ function routeMappingPlugin() {
       }
 
       // 2. 检查是否包含服务调用
-      const serviceCallPattern = new RegExp(`${serviceName}\\.${methodName}\\s*\\(`, 'g')
+      const serviceCallPattern = new RegExp(`${serviceName}\\.${apiMethodName}\\s*\\(`, 'g')
       if (!serviceCallPattern.test(content)) {
-        console.log(`⚠️ 组件 ${componentName} 中没有找到 ${serviceName}.${methodName} 调用`)
+        console.log(`⚠️ 组件 ${componentName} 中没有找到 ${serviceName}.${apiMethodName} 调用`)
         return { triggerSources: [] }
       }
 
-      console.log(`✅ 组件 ${componentName} 中包含 ${serviceName}.${methodName} 调用`)
+      console.log(`✅ 组件 ${componentName} 中包含 ${serviceName}.${apiMethodName} 调用`)
 
-      // 3. 查找调用该API方法的具体方法名
-      const callingMethods = this.findMethodsCallingServiceInText(content, serviceName, methodName)
-      console.log(`🔍 找到调用 ${serviceName}.${methodName} 的方法:`, callingMethods)
+      // 3. 使用Babel AST分析找到调用该API的方法
+      const callingMethods = this.findMethodsCallingServiceWithBabel(content, serviceName, apiMethodName)
+      console.log(`🔍 Babel找到调用 ${serviceName}.${apiMethodName} 的方法:`, callingMethods)
 
-      // 4. 先查找Vue模板中调用这些方法的按钮和控件
-      if (content.includes('<template>') && callingMethods.length > 0) {
-        const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/)
-        if (templateMatch) {
-          const templateContent = templateMatch[1]
-          const templateTriggers = this.findTriggersInTemplateForMethods(templateContent, componentName, callingMethods)
-          triggerSources.push(...templateTriggers)
-        }
+      // 4. 分析每个调用方法的触发源
+      if (callingMethods.length > 0) {
+        const methodTriggers = this.analyzeMethodTriggerSources(content, componentName, callingMethods, filePath)
+        triggerSources.push(...methodTriggers)
       }
 
       // 5. 如果没有找到具体的按钮触发器，才记录页面级别的调用
@@ -652,6 +684,263 @@ function routeMappingPlugin() {
       return { triggerSources: triggerSources }
     },
 
+    // 使用Babel AST分析查找调用指定服务方法的方法
+    findMethodsCallingServiceWithBabel(content, serviceName, apiMethodName) {
+      const callingMethods = []
+      console.log(`🔍 [Babel分析] 开始分析 ${serviceName}.${apiMethodName} 的调用`)
+      
+      try {
+        // 解析script部分
+        const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/)
+        if (!scriptMatch) {
+          console.log(`⚠️ 没有找到script部分`)
+          return callingMethods
+        }
+        
+        const scriptContent = scriptMatch[1]
+        console.log(`🔍 [Babel分析] 找到script内容，长度: ${scriptContent.length}`)
+        
+        // 使用Babel解析JavaScript
+        const { parse } = require('@babel/parser')
+        const traverse = require('@babel/traverse').default
+        
+        const ast = parse(scriptContent, {
+          sourceType: 'module',
+          plugins: ['jsx', 'typescript']
+        })
+        
+        console.log(`✅ [Babel分析] AST解析成功`)
+        
+        // 遍历AST查找方法定义
+        const self = this
+        traverse(ast, {
+          // 查找const方法定义
+          VariableDeclarator(path) {
+            if (path.node.id && path.node.id.type === 'Identifier' && 
+                path.node.init && path.node.init.type === 'ArrowFunctionExpression') {
+              
+              const componentMethodName = path.node.id.name
+              const methodPath = path.get('init')
+              
+              // 检查该方法是否调用了指定的API
+              if (self.checkMethodCallsServiceWithBabel(methodPath, serviceName, apiMethodName)) {
+                callingMethods.push(componentMethodName)
+                console.log(`✅ 找到调用 ${serviceName}.${apiMethodName} 的const方法: ${componentMethodName}`)
+              }
+            }
+          },
+          
+          // 查找ObjectMethod定义
+          ObjectMethod(path) {
+            if (path.node.key && path.node.key.type === 'Identifier') {
+              const componentMethodName = path.node.key.name
+              const methodPath = path
+              
+              // 检查该方法是否调用了指定的API
+              if (self.checkMethodCallsServiceWithBabel(methodPath, serviceName, apiMethodName)) {
+                callingMethods.push(componentMethodName)
+                console.log(`✅ 找到调用 ${serviceName}.${apiMethodName} 的ObjectMethod: ${componentMethodName}`)
+              }
+            }
+          }
+        })
+        
+      } catch (error) {
+        console.warn(`⚠️ Babel分析失败: ${error.message}`)
+      }
+      
+      return callingMethods
+    },
+
+    // 使用Babel检查方法是否调用了指定的service方法
+    checkMethodCallsServiceWithBabel(methodPath, serviceName, apiMethodName) {
+      let hasServiceCall = false
+      console.log(`🔍 [Babel检查] 检查方法是否调用 ${serviceName}.${apiMethodName}`)
+      
+      const traverse = require('@babel/traverse').default
+      
+      traverse(methodPath.node, {
+        CallExpression(path) {
+          const node = path.node
+          if (node.callee && node.callee.type === 'MemberExpression') {
+            const object = node.callee.object
+            const property = node.callee.property
+            
+            if (object && property && 
+                object.type === 'Identifier' && 
+                property.type === 'Identifier') {
+              console.log(`🔍 [Babel检查] 发现调用: ${object.name}.${property.name}`)
+              
+              if (object.name === serviceName && property.name === apiMethodName) {
+                hasServiceCall = true
+                console.log(`✅ [Babel检查] 匹配到API调用: ${serviceName}.${apiMethodName}`)
+              }
+            }
+          }
+        }
+      }, methodPath.scope, methodPath)
+      
+      console.log(`🔍 [Babel检查] 方法调用检查结果: ${hasServiceCall}`)
+      return hasServiceCall
+    },
+
+    // 分析方法的触发源
+    analyzeMethodTriggerSources(content, componentName, apiMethodNames, filePath = null) {
+      const triggerSources = []
+      
+      console.log(`🔍 分析方法的触发源: ${apiMethodNames.join(', ')}`)
+      
+      // 提取模板部分
+      const templateMatch = content.match(/<template>([\s\S]*?)<\/template>/)
+      if (!templateMatch) {
+        console.log(`⚠️ 没有找到模板部分`)
+        return triggerSources
+      }
+      
+      const templateContent = templateMatch[1]
+      
+      // 使用正则表达式查找调用这些方法的按钮
+      apiMethodNames.forEach(apiMethodName => {
+        console.log(`🔍 查找调用方法 ${apiMethodName} 的按钮`)
+        
+        // 1. 查找@click="apiMethodName"或@click="apiMethodName("
+        const clickPattern = new RegExp(`@click\\s*=\\s*["']${apiMethodName}\\s*\\([^)]*\\)["']`, 'g')
+        const clickMatches = templateContent.match(clickPattern)
+        
+        if (clickMatches) {
+          console.log(`  ✅ 找到 ${clickMatches.length} 个调用 ${apiMethodName} 的@click按钮`)
+          
+          clickMatches.forEach((match, index) => {
+            // 查找包含这个@click的button标签
+            const buttonMatch = this.findButtonContainingClick(templateContent, match)
+            if (buttonMatch) {
+              const buttonName = this.extractButtonName(buttonMatch)
+              const triggerType = buttonName ? 'button' : 'button' // 有name就是button，没有name也是button但需要生成name
+              
+              triggerSources.push({
+                component: componentName,
+                triggerName: buttonName || this.generateUniqueButtonName(componentName, apiMethodName),
+                triggerType: triggerType
+              })
+              
+              console.log(`    ✅ @click按钮 ${index + 1}: ${buttonName || '无name'} -> ${apiMethodName}`)
+              
+              // 如果按钮没有name属性，添加name属性
+              if (!buttonName && filePath) {
+                this.addNameAttributeToButton(filePath, buttonMatch, this.generateUniqueButtonName(componentName, apiMethodName))
+              }
+            }
+          })
+        }
+        
+        // 2. 查找@submit.prevent="apiMethodName"的表单提交按钮
+        const submitPattern = new RegExp(`@submit\\.prevent\\s*=\\s*["']${apiMethodName}["']`, 'g')
+        const submitMatches = templateContent.match(submitPattern)
+        
+        if (submitMatches) {
+          console.log(`  ✅ 找到 ${submitMatches.length} 个调用 ${apiMethodName} 的表单提交`)
+          
+          submitMatches.forEach((match, index) => {
+            // 查找包含这个@submit.prevent的form标签
+            const formMatch = this.findFormContainingSubmit(templateContent, match)
+            if (formMatch) {
+              // 查找表单中的type="submit"按钮
+              const submitButtonMatch = this.findSubmitButtonInForm(formMatch)
+              if (submitButtonMatch) {
+                const buttonName = this.extractButtonName(submitButtonMatch)
+                const triggerType = buttonName ? 'button' : 'button'
+                
+                triggerSources.push({
+                  component: componentName,
+                  triggerName: buttonName || this.generateUniqueButtonName(componentName, apiMethodName),
+                  triggerType: triggerType
+                })
+                
+                console.log(`    ✅ 表单提交按钮 ${index + 1}: ${buttonName || '无name'} -> ${apiMethodName}`)
+                
+                // 如果按钮没有name属性，添加name属性
+                if (!buttonName && filePath) {
+                  this.addNameAttributeToButton(filePath, submitButtonMatch, this.generateUniqueButtonName(componentName, apiMethodName))
+                }
+              } else {
+                // 如果没有找到具体的提交按钮，记录为form类型
+                triggerSources.push({
+                  component: componentName,
+                  triggerName: null,
+                  triggerType: 'form'
+                })
+                
+                console.log(`    ✅ 表单提交 ${index + 1}: form类型 -> ${apiMethodName}`)
+              }
+            }
+          })
+        }
+        
+        // 3. 如果既没有@click也没有@submit，记录为页面级调用
+        if (!clickMatches && !submitMatches) {
+          console.log(`  ⚠️ 没有找到调用 ${apiMethodName} 的按钮或表单`)
+        }
+      })
+      
+      return triggerSources
+    },
+
+    // 查找包含指定@click的button标签
+    findButtonContainingClick(templateContent, clickMatch) {
+      const lines = templateContent.split('\n')
+      const clickIndex = templateContent.indexOf(clickMatch)
+      
+      if (clickIndex === -1) return null
+      
+      // 从@click位置往前查找最近的<button标签
+      const beforeClick = templateContent.substring(0, clickIndex)
+      const lastButtonIndex = beforeClick.lastIndexOf('<button')
+      
+      if (lastButtonIndex === -1) return null
+      
+      // 从<button开始往后查找对应的</button>
+      const afterButton = templateContent.substring(lastButtonIndex)
+      const buttonEndIndex = afterButton.indexOf('</button>')
+      
+      if (buttonEndIndex === -1) return null
+      
+      return afterButton.substring(0, buttonEndIndex + 9) // 包含</button>
+    },
+
+    // 从button标签中提取name属性
+    extractButtonName(buttonHtml) {
+      const nameMatch = buttonHtml.match(/name\s*=\s*["']([^"']+)["']/)
+      return nameMatch ? nameMatch[1] : null
+    },
+
+    // 查找包含指定@submit.prevent的form标签
+    findFormContainingSubmit(templateContent, submitMatch) {
+      const submitIndex = templateContent.indexOf(submitMatch)
+      
+      if (submitIndex === -1) return null
+      
+      // 从@submit.prevent位置往前查找最近的<form标签
+      const beforeSubmit = templateContent.substring(0, submitIndex)
+      const lastFormIndex = beforeSubmit.lastIndexOf('<form')
+      
+      if (lastFormIndex === -1) return null
+      
+      // 从<form开始往后查找对应的</form>
+      const afterForm = templateContent.substring(lastFormIndex)
+      const formEndIndex = afterForm.indexOf('</form>')
+      
+      if (formEndIndex === -1) return null
+      
+      return afterForm.substring(0, formEndIndex + 7) // 包含</form>
+    },
+
+    // 在表单中查找type="submit"的按钮
+    findSubmitButtonInForm(formHtml) {
+      const submitButtonPattern = /<button[^>]*type\s*=\s*["']submit["'][^>]*>[\s\S]*?<\/button>/g
+      const match = submitButtonPattern.exec(formHtml)
+      return match ? match[0] : null
+    },
+
     // 在模板中查找触发器 - 简化版本
     findTriggersInTemplateSimple(templateContent, componentName) {
       const triggerSources = []
@@ -712,11 +1001,11 @@ function routeMappingPlugin() {
     },
 
     // 分析组件中的触发器源
-    analyzeComponentForTriggerSources(componentName, componentPath, moduleName, serviceName, methodName) {
+    analyzeComponentForTriggerSources(componentName, componentPath, moduleName, serviceName, apiMethodName) {
       try {
         let filePath = componentPath
         
-        console.log(`🔍 分析组件 ${componentName}，查找服务 ${serviceName}.${methodName}`)
+        console.log(`🔍 分析组件 ${componentName}，查找服务 ${serviceName}.${apiMethodName}`)
         
         // 如果是组件名，需要找到对应的文件
         if (!filePath || !existsSync(filePath)) {
@@ -732,9 +1021,9 @@ function routeMappingPlugin() {
         const content = readFileSync(filePath, 'utf-8')
         
         if (filePath.endsWith('.vue')) {
-          return this.analyzeVueComponentForTriggerSources(content, componentName, moduleName, serviceName, methodName)
+          return this.analyzeVueComponentForTriggerSources(content, componentName, moduleName, serviceName, apiMethodName)
         } else {
-          return this.analyzeJavaScriptComponentForTriggerSources(content, componentName, moduleName, serviceName, methodName)
+          return this.analyzeJavaScriptComponentForTriggerSources(content, componentName, moduleName, serviceName, apiMethodName)
         }
       } catch (error) {
         console.warn(`⚠️ 分析组件触发器源失败: ${componentName}`, error.message)
@@ -743,7 +1032,7 @@ function routeMappingPlugin() {
     },
 
     // 分析Vue组件中的触发器源
-    analyzeVueComponentForTriggerSources(content, componentName, moduleName, serviceName, methodName) {
+    analyzeVueComponentForTriggerSources(content, componentName, moduleName, serviceName, apiMethodName) {
       const { descriptor } = parse(content)
       const scriptContent = descriptor.script?.content || ''
       const templateContent = descriptor.template?.content || ''
@@ -761,8 +1050,8 @@ function routeMappingPlugin() {
         plugins: ['jsx']
       })
       
-      const callingMethods = this.findMethodsCallingService(ast, serviceName, methodName)
-      console.log(`🔍 在组件 ${componentName} 中找到调用 ${serviceName}.${methodName} 的方法:`, callingMethods)
+      const callingMethods = this.findMethodsCallingService(ast, serviceName, apiMethodName)
+      console.log(`🔍 在组件 ${componentName} 中找到调用 ${serviceName}.${apiMethodName} 的方法:`, callingMethods)
       
       if (callingMethods.length === 0) {
         return { triggerSources: [] }
@@ -775,13 +1064,13 @@ function routeMappingPlugin() {
     },
 
     // 分析JavaScript组件中的触发器源
-    analyzeJavaScriptComponentForTriggerSources(content, componentName, moduleName, serviceName, methodName) {
+    analyzeJavaScriptComponentForTriggerSources(content, componentName, moduleName, serviceName, apiMethodName) {
       const ast = parser.parse(content, {
         sourceType: 'module',
         plugins: ['jsx']
       })
       
-      const callingMethods = this.findMethodsCallingService(ast, serviceName, methodName)
+      const callingMethods = this.findMethodsCallingService(ast, serviceName, apiMethodName)
       
       if (callingMethods.length === 0) {
         return { triggerSources: [] }
@@ -798,10 +1087,10 @@ function routeMappingPlugin() {
     },
 
     // 在模板中查找触发器源
-    findTriggerSourcesInTemplate(templateContent, methodNames, componentName) {
+    findTriggerSourcesInTemplate(templateContent, apiMethodNames, componentName) {
       const triggerSources = []
       
-      console.log(`🔍 在组件 ${componentName} 中查找触发器，方法名:`, methodNames)
+      console.log(`🔍 在组件 ${componentName} 中查找触发器，方法名:`, apiMethodNames)
       
       // 查找button元素 - 改进正则表达式
       const buttonRegex = /<button[^>]*name\s*=\s*["']([^"']+)["'][^>]*@click\s*=\s*["']([^"']+)["'][^>]*>/g
@@ -813,8 +1102,8 @@ function routeMappingPlugin() {
         
         console.log(`🔍 找到按钮: ${buttonName}, 点击处理器: ${clickHandler}`)
         
-        // 检查clickHandler是否在methodNames中
-        if (methodNames.includes(clickHandler)) {
+        // 检查clickHandler是否在apiMethodNames中
+        if (apiMethodNames.includes(clickHandler)) {
           triggerSources.push({
             component: componentName,
             triggerName: buttonName,
@@ -832,8 +1121,8 @@ function routeMappingPlugin() {
         
         console.log(`🔍 找到无name按钮，点击处理器: ${clickHandler}`)
         
-        // 检查clickHandler是否在methodNames中
-        if (methodNames.includes(clickHandler)) {
+        // 检查clickHandler是否在apiMethodNames中
+        if (apiMethodNames.includes(clickHandler)) {
           triggerSources.push({
             component: componentName,
             triggerName: null,
@@ -854,8 +1143,8 @@ function routeMappingPlugin() {
         
         console.log(`🔍 找到控件: ${elementName}, 事件处理器: ${eventHandler}`)
         
-        // 检查eventHandler是否在methodNames中
-        if (methodNames.includes(eventHandler)) {
+        // 检查eventHandler是否在apiMethodNames中
+        if (apiMethodNames.includes(eventHandler)) {
           triggerSources.push({
             component: componentName,
             triggerName: elementName,
@@ -866,7 +1155,7 @@ function routeMappingPlugin() {
       }
       
       // 如果没有找到具体的控件，但有调用方法，则记录组件名
-      if (triggerSources.length === 0 && methodNames.length > 0) {
+      if (triggerSources.length === 0 && apiMethodNames.length > 0) {
         triggerSources.push({
           component: componentName,
           triggerName: null,
@@ -922,16 +1211,37 @@ function routeMappingPlugin() {
         const filteredApiMappings = moduleMapping.apiMappings.filter(apiMapping => {
           const hasTriggers = apiMapping.triggerSources && apiMapping.triggerSources.length > 0
           if (!hasTriggers) {
-            console.log(`🗑️ 删除无触发器的API映射: ${apiMapping.methodName}`)
+            console.log(`🗑️ 删除无触发器的API映射: ${apiMapping.apiMethodName}`)
           }
           return hasTriggers
         })
         
-        console.log(`🔍 模块 ${moduleMapping.module} 过滤后API映射数量:`, filteredApiMappings.length)
+        // 去重：移除重复的triggerSources
+        const deduplicatedApiMappings = filteredApiMappings.map(apiMapping => {
+          const uniqueTriggerSources = []
+          const seenTriggers = new Set()
+          
+          apiMapping.triggerSources.forEach(trigger => {
+            const triggerKey = `${trigger.component}-${trigger.triggerName}-${trigger.triggerType}`
+            if (!seenTriggers.has(triggerKey)) {
+              seenTriggers.add(triggerKey)
+              uniqueTriggerSources.push(trigger)
+            } else {
+              console.log(`🗑️ 删除重复的触发器: ${triggerKey}`)
+            }
+          })
+          
+          return {
+            ...apiMapping,
+            triggerSources: uniqueTriggerSources
+          }
+        })
+        
+        console.log(`🔍 模块 ${moduleMapping.module} 去重后API映射数量:`, deduplicatedApiMappings.length)
         
         return {
           ...moduleMapping,
-          apiMappings: filteredApiMappings
+          apiMappings: deduplicatedApiMappings
         }
       }).filter(moduleMapping => moduleMapping.apiMappings.length > 0) // 过滤掉没有API映射的模块
       
@@ -976,7 +1286,7 @@ function routeMappingPlugin() {
     },
 
     // 分析组件中调用特定API方法的服务调用和触发器
-    analyzeComponentForServiceCallsWithTriggers(componentName, componentPath, moduleName, serviceName, methodName) {
+    analyzeComponentForServiceCallsWithTriggers(componentName, componentPath, moduleName, serviceName, apiMethodName) {
       try {
         let filePath = componentPath
         
@@ -993,9 +1303,9 @@ function routeMappingPlugin() {
         const content = readFileSync(filePath, 'utf-8')
         
         if (filePath.endsWith('.vue')) {
-          return this.analyzeVueComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, methodName)
+          return this.analyzeVueComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, apiMethodName)
         } else {
-          return this.analyzeJavaScriptComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, methodName)
+          return this.analyzeJavaScriptComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, apiMethodName)
         }
       } catch (error) {
         console.warn(`⚠️ 分析组件服务调用和触发器失败: ${componentName}`, error.message)
@@ -1004,7 +1314,7 @@ function routeMappingPlugin() {
     },
 
     // 分析Vue组件中的服务调用和触发器
-    analyzeVueComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, methodName) {
+    analyzeVueComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, apiMethodName) {
       const { descriptor } = parse(content)
       const scriptContent = descriptor.script?.content || ''
       const templateContent = descriptor.template?.content || ''
@@ -1019,7 +1329,7 @@ function routeMappingPlugin() {
         plugins: ['jsx']
       })
       
-      const callingMethods = this.findMethodsCallingService(ast, serviceName, methodName)
+      const callingMethods = this.findMethodsCallingService(ast, serviceName, apiMethodName)
       
       if (callingMethods.length === 0) {
         return { hasServiceCall: false, triggerSources: [] }
@@ -1035,13 +1345,13 @@ function routeMappingPlugin() {
     },
 
     // 分析JavaScript组件中的服务调用和触发器
-    analyzeJavaScriptComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, methodName) {
+    analyzeJavaScriptComponentForServiceCallsWithTriggers(content, componentName, moduleName, serviceName, apiMethodName) {
       const ast = parser.parse(content, {
         sourceType: 'module',
         plugins: ['jsx']
       })
       
-      const callingMethods = this.findMethodsCallingService(ast, serviceName, methodName)
+      const callingMethods = this.findMethodsCallingService(ast, serviceName, apiMethodName)
       
       if (callingMethods.length === 0) {
         return { hasServiceCall: false, triggerSources: [] }
@@ -1058,28 +1368,28 @@ function routeMappingPlugin() {
 
 
     // 查找调用指定service方法的方法
-    findMethodsCallingService(ast, serviceName, methodName) {
+    findMethodsCallingService(ast, serviceName, apiMethodName) {
       const callingMethods = []
       const self = this
       
       traverse(ast, {
         ObjectMethod(path) {
-          const methodName = path.node.key?.name
-          if (methodName) {
-            const hasServiceCall = self.checkMethodCallsService(path, serviceName, methodName)
+          const apiMethodName = path.node.key?.name
+          if (apiMethodName) {
+            const hasServiceCall = self.checkMethodCallsService(path, serviceName, apiMethodName)
             if (hasServiceCall) {
-              callingMethods.push(methodName)
+              callingMethods.push(apiMethodName)
             }
           }
         },
         
         ObjectProperty(path) {
           if (path.node.value && (path.node.value.type === 'ArrowFunctionExpression' || path.node.value.type === 'FunctionExpression')) {
-            const methodName = path.node.key?.name
-            if (methodName) {
-              const hasServiceCall = self.checkMethodCallsService(path.get('value'), serviceName, methodName)
+            const apiMethodName = path.node.key?.name
+            if (apiMethodName) {
+              const hasServiceCall = self.checkMethodCallsService(path.get('value'), serviceName, apiMethodName)
               if (hasServiceCall) {
-                callingMethods.push(methodName)
+                callingMethods.push(apiMethodName)
               }
             }
           }
@@ -1090,7 +1400,7 @@ function routeMappingPlugin() {
     },
 
     // 检查方法是否调用了指定的service方法
-    checkMethodCallsService(methodPath, serviceName, methodName) {
+    checkMethodCallsService(methodPath, serviceName, apiMethodName) {
       let hasServiceCall = false
       
       traverse(methodPath.node, {
@@ -1102,7 +1412,7 @@ function routeMappingPlugin() {
             
             if (object && property && 
                 object.name === serviceName && 
-                property.name === methodName) {
+                property.name === apiMethodName) {
               hasServiceCall = true
             }
           }
@@ -1113,7 +1423,7 @@ function routeMappingPlugin() {
     },
 
     // 在template中查找调用指定方法的button
-    findButtonsCallingMethods(templateContent, methodNames, componentName) {
+    findButtonsCallingMethods(templateContent, apiMethodNames, componentName) {
       const triggerSources = []
       
       // 使用正则表达式查找button元素
@@ -1124,8 +1434,8 @@ function routeMappingPlugin() {
         const buttonName = match[1]
         const clickHandler = match[2]
         
-        // 检查clickHandler是否在methodNames中
-        if (methodNames.includes(clickHandler)) {
+        // 检查clickHandler是否在apiMethodNames中
+        if (apiMethodNames.includes(clickHandler)) {
           triggerSources.push(`${componentName}#${buttonName}`)
         }
       }
@@ -1583,92 +1893,357 @@ export default directRouteMappings
       }
     },
 
-    // 在文本中查找调用指定service方法的方法名
-    findMethodsCallingServiceInText(content, serviceName, methodName) {
+    // 使用AST分析查找调用指定服务方法的方法
+    findMethodsCallingServiceWithAST(content, serviceName, apiMethodName) {
       const callingMethods = []
+      console.log(`🔍 [AST分析] 开始分析 ${serviceName}.${apiMethodName} 的调用`)
       
       try {
         // 解析script部分
         const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/)
         if (!scriptMatch) {
+          console.log(`⚠️ [AST分析] 没有找到script标签`)
           return callingMethods
         }
         
         const scriptContent = scriptMatch[1]
+        console.log(`🔍 [AST分析] 找到script内容，长度: ${scriptContent.length}`)
         
-        // 使用更简单的方法：先找到所有const方法定义，然后检查每个方法
-        const constMethodMatches = scriptContent.match(/const\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>\s*\{/g)
-        if (constMethodMatches) {
-          for (const methodMatch of constMethodMatches) {
-            const methodNameMatch = methodMatch.match(/const\s+(\w+)\s*=/)
-            if (methodNameMatch) {
-              const componentMethodName = methodNameMatch[1]
+        // 使用Babel解析AST进行更准确的分析
+        const ast = parser.parse(scriptContent, {
+          sourceType: 'module',
+          plugins: ['jsx', 'typescript']
+        })
+        console.log(`✅ [AST分析] AST解析成功`)
+        
+        const self = this
+        traverse(ast, {
+          // 查找const方法定义
+          VariableDeclarator(path) {
+            if (path.node.id && path.node.id.type === 'Identifier' && 
+                path.node.init && 
+                (path.node.init.type === 'ArrowFunctionExpression' || 
+                 path.node.init.type === 'FunctionExpression')) {
               
-              // 找到该方法的完整定义（从const开始到对应的}结束）
-              const methodStart = scriptContent.indexOf(methodMatch)
-              let braceCount = 0
-              let methodEnd = methodStart
-              let inMethod = false
+              const componentMethodName = path.node.id.name
+              const methodPath = path.get('init')
               
-              for (let i = methodStart; i < scriptContent.length; i++) {
-                const char = scriptContent[i]
-                if (char === '{') {
-                  braceCount++
-                  inMethod = true
-                } else if (char === '}') {
-                  braceCount--
-                  if (inMethod && braceCount === 0) {
-                    methodEnd = i + 1
-                    break
-                  }
-                }
+              // 检查该方法是否调用了指定的API
+              if (self.checkMethodCallsServiceAST(methodPath, serviceName, apiMethodName)) {
+                callingMethods.push(componentMethodName)
+                console.log(`✅ 找到调用 ${serviceName}.${apiMethodName} 的const方法: ${componentMethodName}`)
               }
+            }
+          },
+          
+          // 查找methods对象中的方法定义
+          ObjectMethod(path) {
+            if (path.node.key && path.node.key.type === 'Identifier') {
+              const componentMethodName = path.node.key.name
               
-              const methodContent = scriptContent.substring(methodStart, methodEnd)
+              // 检查该方法是否调用了指定的API
+              if (self.checkMethodCallsServiceAST(path, serviceName, apiMethodName)) {
+                callingMethods.push(componentMethodName)
+                console.log(`✅ 找到调用 ${serviceName}.${apiMethodName} 的ObjectMethod: ${componentMethodName}`)
+              }
+            }
+          },
+          
+          // 查找对象属性中的方法定义
+          ObjectProperty(path) {
+            if (path.node.key && path.node.key.type === 'Identifier' &&
+                path.node.value && 
+                (path.node.value.type === 'ArrowFunctionExpression' || 
+                 path.node.value.type === 'FunctionExpression')) {
+              
+              const componentMethodName = path.node.key.name
+              const methodPath = path.get('value')
               
               // 检查该方法是否调用了指定的API
-              const apiCallPattern = new RegExp(`${serviceName}\\.${methodName}\\s*\\(`, 'g')
-              if (apiCallPattern.test(methodContent)) {
+              if (self.checkMethodCallsServiceAST(methodPath, serviceName, apiMethodName)) {
                 callingMethods.push(componentMethodName)
-                console.log(`✅ 找到调用 ${serviceName}.${methodName} 的const方法: ${componentMethodName}`)
+                console.log(`✅ 找到调用 ${serviceName}.${apiMethodName} 的ObjectProperty: ${componentMethodName}`)
               }
             }
           }
+        })
+        
+      } catch (error) {
+        console.warn(`⚠️ AST分析失败，回退到正则表达式: ${error.message}`)
+        console.warn(`⚠️ 错误堆栈: ${error.stack}`)
+        // 回退到正则表达式方法
+        return this.findMethodsCallingServiceInTextRegex(content, serviceName, apiMethodName)
+      }
+      
+      return callingMethods
+    },
+
+    // 使用AST分析模板中的事件绑定
+    findTriggersInTemplateWithAST(templateContent, componentName, apiMethodNames, filePath = null) {
+      const triggerSources = []
+      const processedButtons = new Set() // 用于跟踪已处理的按钮，避免重复关联
+      
+      console.log(`🔍 AST分析模板中调用方法 ${apiMethodNames.join(', ')} 的触发器`)
+      
+      try {
+        // 使用Vue模板编译器解析模板
+        const { parse } = require('@vue/compiler-sfc')
+        const { compileTemplate } = require('@vue/compiler-sfc')
+        
+        // 创建一个完整的Vue单文件组件用于解析
+        const fullComponent = `<template>${templateContent}</template>`
+        const { descriptor } = parse(fullComponent)
+        
+        if (!descriptor.template) {
+          console.log(`⚠️ 没有找到模板内容`)
+          return triggerSources
         }
         
-        // 查找Vue 2 Options API的方法定义：methods: { methodName() { ... } }
-        const methodsObjectRegex = /methods\s*:\s*\{([\s\S]*?)\}/g
-        while ((match = methodsObjectRegex.exec(scriptContent)) !== null) {
-          const methodsContent = match[1]
-          const methodDefRegex = /(\w+)\s*\([^)]*\)\s*\{[\s\S]*?\}/g
-          let methodMatch
+        console.log(`🔍 模板内容长度: ${templateContent.length}`)
+        console.log(`🔍 模板内容前100字符: ${templateContent.substring(0, 100)}`)
+        
+        // 编译模板获取AST
+        const { ast } = compileTemplate({
+          source: templateContent,
+          filename: 'template.vue',
+          compilerOptions: {
+            hoistStatic: false,
+            cacheHandlers: false
+          }
+        })
+        
+        console.log(`✅ 模板AST解析成功`)
+        console.log(`🔍 AST根节点类型: ${ast.type}, 标签: ${ast.tag}`)
+        console.log(`🔍 AST子节点数量: ${ast.children ? ast.children.length : 0}`)
+        
+        // 遍历AST找到事件绑定
+        this.traverseTemplateAST(ast, (node) => {
+          console.log(`🔍 AST遍历节点:`, {
+            type: node.type,
+            tag: node.tag,
+            props: node.props ? node.props.map(p => ({ name: p.name, value: p.value?.content })) : [],
+            children: node.children ? node.children.length : 0
+          })
           
-          while ((methodMatch = methodDefRegex.exec(methodsContent)) !== null) {
-            const componentMethodName = methodMatch[1]
-            const methodStart = methodMatch.index
-            const methodEnd = methodStart + methodMatch[0].length
-            const methodContent = methodsContent.substring(methodStart, methodEnd)
+          if (node.type === 1 && node.tag === 'button') { // 元素节点且是button标签
+            console.log(`🔍 AST找到button节点:`, {
+              tag: node.tag,
+              props: node.props ? node.props.map(p => ({ name: p.name, value: p.value?.content })) : []
+            })
+            this.processButtonNode(node, componentName, apiMethodNames, triggerSources, processedButtons, filePath)
+          }
+        })
+        
+      } catch (error) {
+        console.warn(`⚠️ 模板AST分析失败: ${error.message}`)
+        console.warn(`⚠️ 错误堆栈: ${error.stack}`)
+      }
+      
+      return triggerSources
+    },
+
+    // 遍历模板AST
+    traverseTemplateAST(node, callback) {
+      callback(node)
+      if (node.children) {
+        node.children.forEach(child => {
+          // 遍历所有类型的子节点
+          this.traverseTemplateAST(child, callback)
+        })
+      }
+      // 也遍历其他可能的子节点属性
+      if (node.branches) {
+        node.branches.forEach(branch => {
+          this.traverseTemplateAST(branch, callback)
+        })
+      }
+      if (node.alternate) {
+        this.traverseTemplateAST(node.alternate, callback)
+      }
+      if (node.consequent) {
+        this.traverseTemplateAST(node.consequent, callback)
+      }
+    },
+
+    // 处理按钮节点
+    processButtonNode(node, componentName, apiMethodNames, triggerSources, processedButtons, filePath) {
+      // 获取按钮的name属性
+      let buttonName = null
+      let clickHandler = null
+      
+      // 查找属性
+      if (node.props) {
+        for (const prop of node.props) {
+          if (prop.name === 'name' && prop.value && prop.value.content) {
+            buttonName = prop.value.content
+          }
+          
+          // Vue模板编译器会将@click转换为on属性，type为7表示指令
+          if (prop.type === 7 && prop.name === 'on' && prop.arg && prop.arg.content === 'click') {
+            // 从AST中提取click事件的处理函数
+            if (prop.exp && prop.exp.children) {
+              // 查找方法名（type为4的节点，包含_ctx.前缀）
+              const apiMethodName = prop.exp.children.find(child => 
+                child.type === 4 && child.content && child.content.includes('_ctx.')
+              )
+              if (apiMethodName) {
+                // 从_ctx.deleteRole中提取deleteRole
+                clickHandler = apiMethodName.content.replace('_ctx.', '')
+                
+                // 检查是否有参数（查找'('字符）
+                const hasArgs = prop.exp.children.some(child => child === '(')
+                if (hasArgs) {
+                  // 查找参数
+                  const paramIndex = prop.exp.children.findIndex(child => child === '(')
+                  if (paramIndex !== -1 && paramIndex + 1 < prop.exp.children.length) {
+                    const param = prop.exp.children[paramIndex + 1]
+                    if (param && param.type === 4 && param.content) {
+                      const paramName = param.content.replace('_ctx.', '')
+                      clickHandler += `(${paramName})`
+                    } else {
+                      clickHandler += '()'
+                    }
+                  } else {
+                    clickHandler += '()'
+                  }
+                }
+              }
+            }
+          }
+          
+          // 也检查其他可能的事件属性名
+          if (prop.name === 'onClick' && prop.value && prop.value.content) {
+            clickHandler = prop.value.content
+          }
+          if (prop.name === 'onclick' && prop.value && prop.value.content) {
+            clickHandler = prop.value.content
+          }
+        }
+      }
+      
+      if (!clickHandler) {
+        return // 没有点击事件，跳过
+      }
+      
+      console.log(`🔍 AST找到按钮: ${buttonName || '无name'}, 点击处理器: ${clickHandler}`)
+      
+      // 检查方法名是否匹配
+      const isMatch = apiMethodNames.some(apiMethodName => {
+        return clickHandler === apiMethodName || clickHandler.startsWith(apiMethodName + '(')
+      })
+      
+      if (isMatch) {
+        if (buttonName) {
+          // 有name属性的按钮
+          const buttonKey = `${componentName}-${buttonName}`
+          if (!processedButtons.has(buttonKey)) {
+            processedButtons.add(buttonKey)
+            triggerSources.push({
+              component: componentName,
+              triggerName: buttonName,
+              triggerType: 'button'
+            })
+            console.log(`✅ AST匹配到按钮触发器: ${buttonName} -> ${clickHandler}`)
+          } else {
+            console.log(`⏭️ AST跳过已处理的按钮: ${buttonName}`)
+          }
+        } else {
+          // 没有name属性的按钮
+          const buttonKey = `${componentName}-${clickHandler}`
+          if (!processedButtons.has(buttonKey)) {
+            processedButtons.add(buttonKey)
+            
+            // 生成唯一的按钮名称
+            const generatedName = this.generateUniqueButtonName(componentName, clickHandler)
             
-            const apiCallPattern = new RegExp(`${serviceName}\\.${methodName}\\s*\\(`, 'g')
+            // 如果提供了文件路径，修改文件添加name属性
+            if (filePath) {
+              this.addNameAttributeToButton(filePath, `<button`, generatedName)
+            }
+            
+            triggerSources.push({
+              component: componentName,
+              triggerName: generatedName,
+              triggerType: 'button'
+            })
+            console.log(`✅ AST匹配到无name按钮触发器: ${clickHandler} (已生成名称: ${generatedName})`)
+          } else {
+            console.log(`⏭️ AST跳过已处理的无name按钮: ${clickHandler}`)
+          }
+        }
+      }
+    },
+
+    // 使用AST检查方法是否调用了指定的service方法（支持间接调用）
+    checkMethodCallsServiceAST(methodPath, serviceName, apiMethodName) {
+      let hasServiceCall = false
+      console.log(`🔍 [AST检查] 检查方法是否调用 ${serviceName}.${apiMethodName}`)
+      
+      traverse(methodPath.node, {
+        CallExpression(path) {
+          const node = path.node
+          if (node.callee && node.callee.type === 'MemberExpression') {
+            const object = node.callee.object
+            const property = node.callee.property
+            
+            if (object && property && 
+                object.type === 'Identifier' && 
+                property.type === 'Identifier') {
+              console.log(`🔍 [AST检查] 发现调用: ${object.name}.${property.name}`)
+              
+              if (object.name === serviceName && property.name === apiMethodName) {
+                hasServiceCall = true
+                console.log(`✅ [AST检查] 匹配到API调用: ${serviceName}.${apiMethodName}`)
+              }
+            }
+          }
+        }
+      }, methodPath.scope, methodPath)
+      
+      console.log(`🔍 [AST检查] 方法调用检查结果: ${hasServiceCall}`)
+      return hasServiceCall
+    },
+
+    // 回退的正则表达式方法
+    findMethodsCallingServiceInTextRegex(content, serviceName, apiMethodName) {
+      const callingMethods = []
+      
+      try {
+        const scriptMatch = content.match(/<script[^>]*>([\s\S]*?)<\/script>/)
+        if (!scriptMatch) {
+          return callingMethods
+        }
+        
+        const scriptContent = scriptMatch[1]
+        
+        // 简单的正则表达式匹配作为回退
+        const methodRegex = /(?:const\s+(\w+)\s*=\s*(?:async\s+)?\([^)]*\)\s*=>\s*\{|(\w+)\s*\([^)]*\)\s*\{)[\s\S]*?\}/g
+        let match
+        
+        while ((match = methodRegex.exec(scriptContent)) !== null) {
+          const apiMethodName = match[1] || match[2]
+          if (apiMethodName) {
+            const methodContent = match[0]
+            const apiCallPattern = new RegExp(`${serviceName}\\.${apiMethodName}\\s*\\(`, 'g')
             if (apiCallPattern.test(methodContent)) {
-              callingMethods.push(componentMethodName)
-              console.log(`✅ 找到调用 ${serviceName}.${methodName} 的methods方法: ${componentMethodName}`)
+              callingMethods.push(apiMethodName)
+              console.log(`✅ 正则表达式找到调用 ${serviceName}.${apiMethodName} 的方法: ${apiMethodName}`)
             }
           }
         }
         
       } catch (error) {
-        console.warn(`⚠️ 查找方法调用失败: ${error.message}`)
+        console.warn(`⚠️ 正则表达式查找方法调用失败: ${error.message}`)
       }
       
       return callingMethods
     },
 
     // 在模板中查找调用指定方法的触发器
-    findTriggersInTemplateForMethods(templateContent, componentName, methodNames) {
+    findTriggersInTemplateForMethods(templateContent, componentName, apiMethodNames, filePath = null) {
       const triggerSources = []
       
-      console.log(`🔍 在模板中查找调用方法 ${methodNames.join(', ')} 的触发器`)
+      console.log(`🔍 在模板中查找调用方法 ${apiMethodNames.join(', ')} 的触发器`)
       
       // 查找有name属性的button元素
       const buttonWithNameRegex = /<button[^>]*name\s*=\s*["']([^"']+)["'][^>]*@click\s*=\s*["']([^"']+)["'][^>]*>/g
@@ -1680,8 +2255,12 @@ export default directRouteMappings
         
         console.log(`🔍 找到按钮: ${buttonName}, 点击处理器: ${clickHandler}`)
         
-        // 检查clickHandler是否在methodNames中
-        if (methodNames.includes(clickHandler)) {
+        // 检查方法名是否匹配（支持带参数的情况）
+        const isMatch = apiMethodNames.some(apiMethodName => {
+          return clickHandler === apiMethodName || clickHandler.startsWith(apiMethodName + '(')
+        })
+        
+        if (isMatch) {
           triggerSources.push({
             component: componentName,
             triggerName: buttonName,
@@ -1699,14 +2278,26 @@ export default directRouteMappings
         
         console.log(`🔍 找到无name按钮，点击处理器: ${clickHandler}`)
         
-        // 检查clickHandler是否在methodNames中
-        if (methodNames.includes(clickHandler)) {
+        // 检查方法名是否匹配（支持带参数的情况）
+        const isMatch = apiMethodNames.some(apiMethodName => {
+          return clickHandler === apiMethodName || clickHandler.startsWith(apiMethodName + '(')
+        })
+        
+        if (isMatch) {
+          // 生成唯一的按钮名称
+          const generatedName = this.generateUniqueButtonName(componentName, clickHandler)
+          
+          // 如果提供了文件路径，修改文件添加name属性
+          if (filePath) {
+            this.addNameAttributeToButton(filePath, match[0], generatedName)
+          }
+          
           triggerSources.push({
             component: componentName,
-            triggerName: "", // 设置为空字符串，提示用户需要补充name属性
+            triggerName: generatedName, // 使用生成的名称
             triggerType: 'button'
           })
-          console.log(`✅ 匹配到无name按钮触发器: ${clickHandler} (需要补充name属性)`)
+          console.log(`✅ 匹配到无name按钮触发器: ${clickHandler} (已生成名称: ${generatedName})`)
         }
       }
       
@@ -1720,8 +2311,12 @@ export default directRouteMappings
         
         console.log(`🔍 找到表单提交，处理器: ${submitHandler}`)
         
-        // 检查submitHandler是否在methodNames中
-        if (methodNames.includes(submitHandler)) {
+        // 检查方法名是否匹配（支持带参数的情况）
+        const isMatch = apiMethodNames.some(apiMethodName => {
+          return submitHandler === apiMethodName || submitHandler.startsWith(apiMethodName + '(')
+        })
+        
+        if (isMatch) {
           // 查找该表单内的提交按钮
           const formContent = this.extractFormContent(templateContent, formStart)
           const submitButtons = this.findSubmitButtonsInForm(formContent)
@@ -1828,4 +2423,4 @@ export default directRouteMappings
   }
 }
 
-module.exports = { routeMappingPlugin }
+module.exports = { routeMappingPlugin }
\ No newline at end of file