Merge remote-tracking branch 'gva/main'

# Conflicts: # server/go.mod # server/go.sum # server/mcp/api_creator.go # server/mcp/execution_plan_schema.md # server/mcp/gva_auto_generate.go # server/mcp/menu_creator.go # server/mcp/requirement_analyzer.go # server/utils/verify.go
2025-09-09 21:37:59 +08:00
parent f35125cbce 424c5b23b4
commit 05fba0b6a3
71 changed files with 3376 additions and 715 deletions
@@ -41,7 +41,11 @@ type ApiCreator struct{}
 // New 创建API创建工具
 func (a *ApiCreator) New() mcp.Tool {
 	return mcp.NewTool("create_api",
-		mcp.WithDescription("创建后端API记录，用于AI编辑器自动添加API接口时自动创建对应的API权限记录。注意：使用gva_auto_generate创建的包和模块会自动创建API权限，无需调用此工具。仅在AI编辑器自动添加API或router下的文件产生路径变化时使用。"),
+		mcp.WithDescription(`创建后端API记录，用于AI编辑器自动添加API接口时自动创建对应的API权限记录。
+
+**重要限制：**
+- 当使用gva_auto_generate工具且needCreatedModules=true时，模块创建会自动生成API权限，不应调用此工具
+- 仅在以下情况使用：1) 单独创建API（不涉及模块创建）；2) AI编辑器自动添加API；3) router下的文件产生路径变化时`),
 		mcp.WithString("path",
 			mcp.Required(),
 			mcp.Description("API路径，如：/user/create"),
@@ -0,0 +1,165 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/mark3labs/mcp-go/mcp"
+	"go.uber.org/zap"
+)
+
+// 注册工具
+func init() {
+	// 注册工具将在enter.go中统一处理
+	RegisterTool(&ApiLister{})
+}
+
+// ApiInfo API信息结构
+type ApiInfo struct {
+	ID          uint   `json:"id,omitempty"`          // 数据库ID（仅数据库API有）
+	Path        string `json:"path"`                  // API路径
+	Description string `json:"description,omitempty"` // API描述
+	ApiGroup    string `json:"apiGroup,omitempty"`    // API组
+	Method      string `json:"method"`                // HTTP方法
+	Source      string `json:"source"`                // 来源：database 或 gin
+}
+
+// ApiListResponse API列表响应结构
+type ApiListResponse struct {
+	Success      bool      `json:"success"`
+	Message      string    `json:"message"`
+	DatabaseApis []ApiInfo `json:"databaseApis"` // 数据库中的API
+	GinApis      []ApiInfo `json:"ginApis"`      // gin框架中的API
+	TotalCount   int       `json:"totalCount"`   // 总数量
+}
+
+// ApiLister API列表工具
+type ApiLister struct{}
+
+// New 创建API列表工具
+func (a *ApiLister) New() mcp.Tool {
+	return mcp.NewTool("list_all_apis",
+		mcp.WithDescription(`获取系统中所有的API接口，分为两组：
+
+**功能说明：**
+- 返回数据库中已注册的API列表
+- 返回gin框架中实际注册的路由API列表
+- 帮助前端判断是使用现有API还是需要创建新的API,如果api在前端未使用且需要前端调用的时候，请到api文件夹下对应模块的js中添加方法并暴露给当前业务调用
+
+**返回数据结构：**
+- databaseApis: 数据库中的API记录（包含ID、描述、分组等完整信息）
+- ginApis: gin路由中的API（仅包含路径和方法），需要AI根据路径自行揣摩路径的业务含义，例如：/api/user/:id 表示根据用户ID获取用户信息`),
+	)
+}
+
+// Handle 处理API列表请求
+func (a *ApiLister) Handle(_ context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+
+	// 获取数据库中的API
+	databaseApis, err := a.getDatabaseApis()
+	if err != nil {
+		global.GVA_LOG.Error("获取数据库API失败", zap.Error(err))
+		errorResponse := ApiListResponse{
+			Success: false,
+			Message: "获取数据库API失败: " + err.Error(),
+		}
+		resultJSON, _ := json.Marshal(errorResponse)
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.TextContent{
+					Type: "text",
+					Text: string(resultJSON),
+				},
+			},
+		}, nil
+	}
+
+	// 获取gin路由中的API
+	ginApis, err := a.getGinApis()
+	if err != nil {
+		global.GVA_LOG.Error("获取gin路由API失败", zap.Error(err))
+		errorResponse := ApiListResponse{
+			Success: false,
+			Message: "获取gin路由API失败: " + err.Error(),
+		}
+		resultJSON, _ := json.Marshal(errorResponse)
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.TextContent{
+					Type: "text",
+					Text: string(resultJSON),
+				},
+			},
+		}, nil
+	}
+
+	// 构建响应
+	response := ApiListResponse{
+		Success:      true,
+		Message:      "获取API列表成功",
+		DatabaseApis: databaseApis,
+		GinApis:      ginApis,
+		TotalCount:   len(databaseApis) + len(ginApis),
+	}
+
+	global.GVA_LOG.Info("API列表获取成功",
+		zap.Int("数据库API数量", len(databaseApis)),
+		zap.Int("gin路由API数量", len(ginApis)),
+		zap.Int("总数量", response.TotalCount))
+
+	resultJSON, err := json.Marshal(response)
+	if err != nil {
+		return nil, fmt.Errorf("序列化结果失败: %v", err)
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.TextContent{
+				Type: "text",
+				Text: string(resultJSON),
+			},
+		},
+	}, nil
+}
+
+// getDatabaseApis 获取数据库中的所有API
+func (a *ApiLister) getDatabaseApis() ([]ApiInfo, error) {
+	var apis []system.SysApi
+	err := global.GVA_DB.Model(&system.SysApi{}).Order("api_group ASC, path ASC").Find(&apis).Error
+	if err != nil {
+		return nil, err
+	}
+
+	// 转换为ApiInfo格式
+	var result []ApiInfo
+	for _, api := range apis {
+		result = append(result, ApiInfo{
+			ID:          api.ID,
+			Path:        api.Path,
+			Description: api.Description,
+			ApiGroup:    api.ApiGroup,
+			Method:      api.Method,
+			Source:      "database",
+		})
+	}
+
+	return result, nil
+}
+
+// getGinApis 获取gin路由中的所有API（包含被忽略的API）
+func (a *ApiLister) getGinApis() ([]ApiInfo, error) {
+	// 从gin路由信息中获取所有API
+	var result []ApiInfo
+	for _, route := range global.GVA_ROUTERS {
+		result = append(result, ApiInfo{
+			Path:   route.Path,
+			Method: route.Method,
+			Source: "gin",
+		})
+	}
+
+	return result, nil
+}
@@ -1,81 +0,0 @@
-package mcpTool
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"github.com/mark3labs/mcp-go/mcp"
-	"time"
-)
-
-func init() {
-	RegisterTool(&CurrentTime{})
-}
-
-type CurrentTime struct {
-}
-
-// 获取当前系统时间
-func (t *CurrentTime) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	// 获取当前系统时间
-
-	timezone, ok := request.GetArguments()["timezone"].(string)
-
-	if !ok {
-		return nil, errors.New("参数错误：timezone 必须是字符串类型")
-	}
-	// 根据timezone参数加载对应时区
-	loc, err := loadTimeZone(timezone)
-	if err != nil {
-		return nil, err
-	}
-
-	// 获取当前时间并转换为指定时区
-	currentTime := time.Now().In(loc).Format("2006-01-02 15:04:05")
-	//返回
-	return &mcp.CallToolResult{
-		Content: []mcp.Content{
-			mcp.TextContent{
-				Type: "text",
-				Text: fmt.Sprintf("%s 时区的当前时间是：%s", timezone, currentTime),
-			},
-		},
-	}, nil
-}
-
-func (t *CurrentTime) New() mcp.Tool {
-	return mcp.NewTool("currentTime",
-		mcp.WithDescription("获取当前系统时间"),
-		mcp.WithString("timezone",
-			mcp.Required(),
-			mcp.Description("时区"),
-			mcp.Enum("UTC", "CST", "PST", "EST", "GMT", "CET", "JST", "MST", "IST", "AST", "HST"),
-		))
-}
-
-// 将简写时区转换为IANA标准时区
-func loadTimeZone(timezone string) (*time.Location, error) {
-	// 时区映射表
-	timezoneMap := map[string]string{
-		"UTC": "UTC",
-		"CST": "Asia/Shanghai", // 中国标准时间
-		"PST": "America/Los_Angeles",
-		"EST": "America/New_York",
-		"GMT": "GMT",
-		"CET": "Europe/Paris",
-		"JST": "Asia/Tokyo",
-		"MST": "America/Denver",
-		"IST": "Asia/Kolkata",
-		"AST": "Asia/Riyadh", // 阿拉伯标准时间
-		"HST": "Pacific/Honolulu",
-	}
-
-	// 获取标准时区名称
-	tzName, exists := timezoneMap[timezone]
-	if !exists {
-		return nil, errors.New("不支持的时区: " + timezone)
-	}
-
-	// 加载时区
-	return time.LoadLocation(tzName)
-}
@@ -7,13 +7,13 @@ ExecutionPlan 是用于自动化模块创建的执行计划结构体，包含了

 ```go
 type ExecutionPlan struct {
-PackageName        string                           `json:"packageName"`        // 包名，如："user", "order", "product"
-PackageType        string                           `json:"packageType"`        // "plugin" 或 "package"
-NeedCreatedPackage bool                             `json:"needCreatedPackage"` // 是否需要创建包
-NeedCreatedModules bool                             `json:"needCreatedModules"` // 是否需要创建模块
-PackageInfo        *request.SysAutoCodePackageCreate `json:"packageInfo,omitempty"`  // 包信息（当NeedCreatedPackage=true时必需）
-ModulesInfo        []*request.AutoCode              `json:"modulesInfo,omitempty"` // 模块信息数组（当NeedCreatedModules=true时必需，支持批量创建）
-Paths              map[string]string                `json:"paths,omitempty"`       // 路径信息
+    PackageName        string                           `json:"packageName"`        // 包名，如："user", "order", "product"
+    PackageType        string                           `json:"packageType"`        // "plugin" 或 "package"
+    NeedCreatedPackage bool                             `json:"needCreatedPackage"` // 是否需要创建包
+    NeedCreatedModules bool                             `json:"needCreatedModules"` // 是否需要创建模块
+    PackageInfo        *request.SysAutoCodePackageCreate `json:"packageInfo,omitempty"`  // 包信息（当NeedCreatedPackage=true时必需）
+    ModulesInfo        []*request.AutoCode              `json:"modulesInfo,omitempty"` // 模块信息数组（当NeedCreatedModules=true时必需，支持批量创建）
+    Paths              map[string]string                `json:"paths,omitempty"`       // 路径信息
 }
 ```

@@ -501,19 +501,19 @@ type DataSource struct {
 2. **NeedCreatedPackage**: 当为true时，PackageInfo必须提供
 3. **NeedCreatedModules**: 当为true时，ModulesInfo必须提供
 4. **字段类型**: FieldType支持的类型包括：
-    - string（字符串）
-    - richtext（富文本）
-    - int（整型）
-    - bool（布尔值）
-    - float64（浮点型）
-    - time.Time（时间）
-    - enum（枚举）
-    - picture（单图片，字符串）
-    - pictures（多图片，json字符串）
-    - video（视频，字符串）
-    - file（文件，json字符串）
-    - json（JSON）
-    - array（数组）
+   - string（字符串）
+   - richtext（富文本）
+   - int（整型）
+   - bool（布尔值）
+   - float64（浮点型）
+   - time.Time（时间）
+   - enum（枚举）
+   - picture（单图片，字符串）
+   - pictures（多图片，json字符串）
+   - video（视频，字符串）
+   - file（文件，json字符串）
+   - json（JSON）
+   - array（数组）
 5. **搜索类型**: FieldSearchType支持：EQ, NE, GT, GE, LT, LE, LIKE, BETWEEN等
 6. **索引类型**: FieldIndexType支持：index, unique等
 7. **GvaModel**: 设置为true时会自动包含ID、CreatedAt、UpdatedAt、DeletedAt字段
@@ -1,79 +0,0 @@
-package mcpTool
-
-import (
-	"context"
-	"errors"
-	"fmt"
-	"github.com/flipped-aurora/gin-vue-admin/server/global"
-	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
-	"github.com/mark3labs/mcp-go/mcp"
-	"gorm.io/gorm"
-)
-
-func init() {
-	RegisterTool(&GetNickname{})
-}
-
-type GetNickname struct{}
-
-// 根据用户username获取nickname
-func (t *GetNickname) New() mcp.Tool {
-	return mcp.NewTool("getNickname",
-		mcp.WithDescription("根据用户username获取nickname"),
-		mcp.WithString("username",
-			mcp.Required(),
-			mcp.Description("用户的username"),
-		))
-}
-
-// Handle 处理获取昵称的请求
-func (t *GetNickname) Handle(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
-	// 1. 参数验证
-	username, ok := request.GetArguments()["username"].(string)
-	if !ok {
-		return nil, errors.New("参数错误：username 必须是字符串类型")
-	}
-
-	if username == "" {
-		return nil, errors.New("参数错误：username 不能为空")
-	}
-
-	// 2. 记录操作日志
-	global.GVA_LOG.Info("getNickname 工具被调用")
-
-	// 3. 优化查询，只选择需要的字段
-	var user struct {
-		NickName string
-	}
-
-	err := global.GVA_DB.Model(&system.SysUser{}).
-		Select("nick_name").
-		Where("username = ?", username).
-		First(&user).Error
-
-	// 4. 优化错误处理
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return &mcp.CallToolResult{
-				Content: []mcp.Content{
-					mcp.TextContent{
-						Type: "text",
-						Text: fmt.Sprintf("用户 %s 不存在", username),
-					},
-				},
-			}, nil
-		}
-		global.GVA_LOG.Error("数据库查询错误")
-		return nil, errors.New("系统错误，请稍后再试")
-	}
-
-	// 构造回复信息
-	return &mcp.CallToolResult{
-		Content: []mcp.Content{
-			mcp.TextContent{
-				Type: "text",
-				Text: fmt.Sprintf("用户 %s 的昵称是 %s", username, user.NickName),
-			},
-		},
-	}, nil
-}
@@ -9,6 +9,7 @@ import (
 	"path/filepath"
 	"strings"
 	"time"
+	"unicode"

 	"github.com/flipped-aurora/gin-vue-admin/server/global"
 	common "github.com/flipped-aurora/gin-vue-admin/server/model/common/request"
@@ -135,6 +136,10 @@ func (t *AutomationModuleAnalyzer) New() mcp.Tool {
 2. AI分析需求为1xxx2xxx格式 → gva_auto_generate（执行创建）
 3. 创建完成后，根据需要使用其他辅助工具

+**重要限制：**
+- 当needCreatedModules=true时，模块创建会自动生成API和菜单，因此不应再调用api_creator和menu_creator工具
+- 只有在单独创建API或菜单（不涉及模块创建）时才使用api_creator和menu_creator工具
+
 重要：ExecutionPlan结构体格式要求（支持批量创建）：
 {
  "packageName": "包名(string)",
@@ -169,10 +174,10 @@ func (t *AutomationModuleAnalyzer) New() mcp.Tool {
    "generateWeb": "是否生成前端(bool)",
    "generateServer": "是否生成后端(bool)",
    "fields": [{
-      "fieldName": "字段名(string)",
+      "fieldName": "字段名(string)必须大写开头",
      "fieldDesc": "字段描述(string)",
-      "fieldType": "字段类型:string/int/bool/time.Time等(string)",
-      "fieldJson": "JSON标签(string)",
+      "fieldType": "字段类型支持：string（字符串）,richtext（富文本）,int（整型）,bool（布尔值）,float64（浮点型）,time.Time（时间）,enum（枚举）,picture（单图片，字符串）,pictures（多图片，json字符串）,video（视频，字符串）,file（文件，json字符串）,json（JSON）,array（数组）",
+      "fieldJson": "JSON标签(string 必须是小驼峰命名，例:userName)",
      "dataTypeLong": "数据长度(string)",
      "comment": "注释(string)",
      "columnName": "数据库列名(string)",
@@ -184,7 +189,7 @@ func (t *AutomationModuleAnalyzer) New() mcp.Tool {
      "desc": "详情显示(bool)",
      "excel": "导入导出(bool)",
      "require": "是否必填(bool)",
-      "defaultValue": "默认值(string)",
+      "defaultValue": "默认值(string)，JSON类型（array,json,file,pictures）请保持为空他们不可以设置默认值",
      "errorText": "错误提示(string)",
      "clearable": "是否可清空(bool)",
      "sort": "是否排序(bool)",
@@ -803,8 +808,8 @@ func (t *AutomationModuleAnalyzer) handleAnalyze(ctx context.Context, request mc
    "fields": [{
      "fieldName": "字段名（必须大写开头）",
      "fieldDesc": "字段描述",
-      "fieldType": "GO 语言的数据类型",
-      "fieldJson": "json标签",
+      "fieldType": "字段类型支持：string（字符串）,richtext（富文本）,int（整型）,bool（布尔值）,float64（浮点型）,time.Time（时间）,enum（枚举）,picture（单图片，字符串）,pictures（多图片，json字符串）,video（视频，字符串）,file（文件，json字符串）,json（JSON）,array（数组）",
+      "fieldJson": "json标签(string 必须是小驼峰命名，例:userName)",
      "dataTypeLong": "长度",
      "comment": "注释",
      "columnName": "数据库列名",
@@ -1239,6 +1244,7 @@ func (t *AutomationModuleAnalyzer) validateExecutionPlan(plan *ExecutionPlan) er
 				if field.FieldName == "" {
 					return fmt.Errorf("模块 %d 字段 %d 的 fieldName 不能为空", moduleIndex+1, i+1)
 				}
+
 				if field.FieldDesc == "" {
 					return fmt.Errorf("模块 %d 字段 %d 的 fieldDesc 不能为空", moduleIndex+1, i+1)
 				}
@@ -1252,6 +1258,48 @@ func (t *AutomationModuleAnalyzer) validateExecutionPlan(plan *ExecutionPlan) er
 					return fmt.Errorf("模块 %d 字段 %d 的 columnName 不能为空", moduleIndex+1, i+1)
 				}

+				// 确保字段名首字母大写
+				if len(field.FieldName) > 0 {
+					firstChar := string(field.FieldName[0])
+					if firstChar >= "a" && firstChar <= "z" {
+						moduleInfo.Fields[i].FieldName = strings.ToUpper(firstChar) + field.FieldName[1:]
+					}
+				}
+
+				// 确保FieldJson使用小驼峰命名
+				if len(field.FieldJson) > 0 {
+					// 处理下划线命名转小驼峰
+					if strings.Contains(field.FieldJson, "_") {
+						parts := strings.Split(field.FieldJson, "_")
+						camelCase := strings.ToLower(parts[0])
+						for j := 1; j < len(parts); j++ {
+							if len(parts[j]) > 0 {
+								camelCase += strings.ToUpper(string(parts[j][0])) + strings.ToLower(parts[j][1:])
+							}
+						}
+						moduleInfo.Fields[i].FieldJson = camelCase
+					} else {
+						// 处理首字母大写转小写
+						firstChar := string(field.FieldJson[0])
+						if firstChar >= "A" && firstChar <= "Z" {
+							moduleInfo.Fields[i].FieldJson = strings.ToLower(firstChar) + field.FieldJson[1:]
+						}
+					}
+				}
+
+				// 确保ColumnName使用下划线命名
+				if len(field.ColumnName) > 0 {
+					// 将驼峰命名转换为下划线命名
+					var result strings.Builder
+					for i, r := range field.ColumnName {
+						if i > 0 && r >= 'A' && r <= 'Z' {
+							result.WriteRune('_')
+						}
+						result.WriteRune(unicode.ToLower(r))
+					}
+					moduleInfo.Fields[i].ColumnName = result.String()
+				}
+
 				// 验证字段类型
 				validFieldTypes := []string{"string", "int", "int64", "float64", "bool", "time.Time", "enum", "picture", "video", "file", "pictures", "array", "richtext", "json"}
 				validType := false
@@ -1365,6 +1413,13 @@ func (t *AutomationModuleAnalyzer) executeCreation(ctx context.Context, plan *Ex
 		}

 		result.Message += fmt.Sprintf("批量创建完成，共处理 %d 个模块; ", len(plan.ModulesInfo))
+
+		// 添加重要提醒：不要使用其他MCP工具
+		result.Message += "\n\n⚠️ 重要提醒：\n"
+		result.Message += "模块创建已完成，API和菜单已自动生成。请不要再调用以下MCP工具：\n"
+		result.Message += "- api_creator：API权限已在模块创建时自动生成\n"
+		result.Message += "- menu_creator：前端菜单已在模块创建时自动生成\n"
+		result.Message += "如需修改API或菜单，请直接在系统管理界面中进行配置。\n"
 	}

 	result.Message += "已构建目录结构信息; "
@@ -64,7 +64,11 @@ type MenuCreator struct{}
 // New 创建菜单创建工具
 func (m *MenuCreator) New() mcp.Tool {
 	return mcp.NewTool("create_menu",
-		mcp.WithDescription("创建前端菜单记录，用于AI编辑器自动添加前端页面时自动创建对应的菜单项。注意：使用gva_auto_generate创建的包和模块会自动创建菜单项，无需调用此工具。仅在AI编辑器自动添加前端页面时使用。"),
+		mcp.WithDescription(`创建前端菜单记录，用于AI编辑器自动添加前端页面时自动创建对应的菜单项。
+
+**重要限制：**
+- 当使用gva_auto_generate工具且needCreatedModules=true时，模块创建会自动生成菜单项，不应调用此工具
+- 仅在以下情况使用：1) 单独创建菜单（不涉及模块创建）；2) AI编辑器自动添加前端页面时`),
 		mcp.WithNumber("parentId",
 			mcp.Description("父菜单ID，0表示根菜单"),
 			mcp.DefaultNumber(0),
@@ -0,0 +1,112 @@
+package mcpTool
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/flipped-aurora/gin-vue-admin/server/global"
+	"github.com/flipped-aurora/gin-vue-admin/server/model/system"
+	"github.com/mark3labs/mcp-go/mcp"
+	"go.uber.org/zap"
+)
+
+// 注册工具
+func init() {
+	// 注册工具将在enter.go中统一处理
+	RegisterTool(&MenuLister{})
+}
+
+// MenuListResponse 菜单列表响应结构
+type MenuListResponse struct {
+	Success     bool                  `json:"success"`
+	Message     string                `json:"message"`
+	Menus       []system.SysBaseMenu  `json:"menus"`
+	TotalCount  int                   `json:"totalCount"`
+	Description string                `json:"description"`
+}
+
+// MenuLister 菜单列表工具
+type MenuLister struct{}
+
+// New 创建菜单列表工具
+func (m *MenuLister) New() mcp.Tool {
+	return mcp.NewTool("list_all_menus",
+		mcp.WithDescription(`获取系统中所有菜单信息，包括菜单树结构、路由信息、组件路径等，用于前端编写vue-router时正确跳转
+
+**功能说明：**
+- 返回完整的菜单树形结构
+- 包含路由配置信息（path、name、component）
+- 包含菜单元数据（title、icon、keepAlive等）
+- 包含菜单参数和按钮配置
+- 支持父子菜单关系展示
+
+**使用场景：**
+- 前端路由配置：获取所有菜单信息用于配置vue-router
+- 菜单权限管理：了解系统中所有可用的菜单项
+- 导航组件开发：构建动态导航菜单
+- 系统架构分析：了解系统的菜单结构和页面组织`),
+	)
+}
+
+// Handle 处理菜单列表请求
+func (m *MenuLister) Handle(_ context.Context, _ mcp.CallToolRequest) (*mcp.CallToolResult, error) {
+	// 获取所有基础菜单
+	allMenus, err := m.getAllMenus()
+	if err != nil {
+		global.GVA_LOG.Error("获取菜单列表失败", zap.Error(err))
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.TextContent{
+					Type: "text",
+					Text: fmt.Sprintf("获取菜单列表失败: %v", err),
+				},
+			},
+			IsError: true,
+		}, nil
+	}
+
+	// 构建返回结果
+	response := MenuListResponse{
+		Success:     true,
+		Message:     "获取菜单列表成功",
+		Menus:       allMenus,
+		TotalCount:  len(allMenus),
+		Description: "系统中所有菜单信息的标准列表，包含路由配置和组件信息",
+	}
+
+	// 序列化响应
+	responseJSON, err := json.MarshalIndent(response, "", "  ")
+	if err != nil {
+		global.GVA_LOG.Error("序列化菜单响应失败", zap.Error(err))
+		return &mcp.CallToolResult{
+			Content: []mcp.Content{
+				mcp.TextContent{
+					Type: "text",
+					Text: fmt.Sprintf("序列化响应失败: %v", err),
+				},
+			},
+			IsError: true,
+		}, nil
+	}
+
+	return &mcp.CallToolResult{
+		Content: []mcp.Content{
+			mcp.TextContent{
+				Type: "text",
+				Text: string(responseJSON),
+			},
+		},
+	}, nil
+}
+
+// getAllMenus 获取所有基础菜单
+func (m *MenuLister) getAllMenus() ([]system.SysBaseMenu, error) {
+	var menus []system.SysBaseMenu
+	err := global.GVA_DB.Order("sort").Preload("Parameters").Preload("MenuBtn").Find(&menus).Error
+	if err != nil {
+		return nil, err
+	}
+	return menus, nil
+}
+
@@ -20,6 +20,8 @@ type RequirementAnalysisRequest struct {
 	UserRequirement string `json:"userRequirement"`
 }

+
+
 // RequirementAnalysisResponse 需求分析响应
 type RequirementAnalysisResponse struct {
 	AIPrompt string `json:"aiPrompt"` // 给AI的提示词