Implement metadata search in Infinity in GO (#13706)

### What problem does this PR solve?

Add cli

LIST DOCUMENTS OF DATASET quoted_string ";"
LIST METADATA OF DATASETS quoted_string ("," quoted_string)* ";"
LIST METADATA SUMMARY OF DATASET quoted_string (DOCUMENTS quoted_string
("," quoted_string)*)? ";"

### Type of change

- [x] Refactoring

internal/handler/document.go

@@ -203,7 +203,7 @@ func (h *DocumentHandler) DeleteDocument(c *gin.Context) {
 // @Param page query int false "page number" default(1)
 // @Param page_size query int false "items per page" default(10)
 // @Success 200 {object} map[string]interface{}
-// @Router /api/v1/documents [get]
+// @Router /api/v1/document/list [post]
 func (h *DocumentHandler) ListDocuments(c *gin.Context) {
 	_, errorCode, errorMessage := GetUser(c)
 	if errorCode != common.CodeSuccess {
@@ -211,6 +211,16 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
 		return
 	}
 
+	kbID := c.Query("kb_id")
+	if kbID == "" {
+		c.JSON(http.StatusOK, gin.H{
+			"code":    1,
+			"message": "Lack of KB ID",
+			"data":    false,
+		})
+		return
+	}
+
 	page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
 	pageSize, _ := strconv.Atoi(c.DefaultQuery("page_size", "10"))
 
@@ -221,20 +231,41 @@ func (h *DocumentHandler) ListDocuments(c *gin.Context) {
 		pageSize = 10
 	}
 
-	documents, total, err := h.documentService.ListDocuments(page, pageSize)
+	// Use kbID to filter documents
+	documents, total, err := h.documentService.ListDocumentsByKBID(kbID, page, pageSize)
 	if err != nil {
-		c.JSON(http.StatusInternalServerError, gin.H{
-			"error": "failed to get documents",
+		c.JSON(http.StatusOK, gin.H{
+			"code":    1,
+			"message": "failed to get documents",
+			"data":    map[string]interface{}{"total": 0, "docs": []interface{}{}},
 		})
 		return
 	}
 
+	docs := make([]map[string]interface{}, 0, len(documents))
+	for _, doc := range documents {
+		metaFields, err := h.documentService.GetDocumentMetadataByID(doc.ID)
+		if err != nil {
+			metaFields = make(map[string]interface{})
+		}
+
+		docs = append(docs, map[string]interface{}{
+			"id":          doc.ID,
+			"name":        doc.Name,
+			"size":        doc.Size,
+			"type":        doc.Type,
+			"status":      doc.Status,
+			"created_at":  doc.CreatedAt,
+			"meta_fields": metaFields,
+		})
+	}
+
 	c.JSON(http.StatusOK, gin.H{
+		"code":    0,
+		"message": "success",
 		"data": gin.H{
-			"items":     documents,
-			"total":     total,
-			"page":      page,
-			"page_size": pageSize,
+			"total": total,
+			"docs":  docs,
 		},
 	})
 }
@@ -293,3 +324,51 @@ func (h *DocumentHandler) GetDocumentsByAuthorID(c *gin.Context) {
 		},
 	})
 }
+
+// MetadataSummary handles the metadata summary request
+func (h *DocumentHandler) MetadataSummary(c *gin.Context) {
+	_, errorCode, errorMessage := GetUser(c)
+	if errorCode != common.CodeSuccess {
+		jsonError(c, errorCode, errorMessage)
+		return
+	}
+
+	var requestBody struct {
+		KBID   string   `json:"kb_id" binding:"required"`
+		DocIDs []string `json:"doc_ids"`
+	}
+
+	if err := c.ShouldBindJSON(&requestBody); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"code":    1,
+			"message": "kb_id is required",
+		})
+		return
+	}
+
+	kbID := requestBody.KBID
+	if kbID == "" {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"code":    1,
+			"message": "kb_id is required",
+		})
+		return
+	}
+
+	summary, err := h.documentService.GetMetadataSummary(kbID, requestBody.DocIDs)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"code":    1,
+			"message": "Failed to get metadata summary: " + err.Error(),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"code":    0,
+		"message": "success",
+		"data": gin.H{
+			"summary": summary,
+		},
+	})
+}

internal/handler/kb.go

@@ -28,15 +28,17 @@ import (
 
 // KnowledgebaseHandler handles knowledge base HTTP requests
 type KnowledgebaseHandler struct {
-	kbService   *service.KnowledgebaseService
-	userService *service.UserService
+	kbService       *service.KnowledgebaseService
+	userService     *service.UserService
+	documentService *service.DocumentService
 }
 
 // NewKnowledgebaseHandler creates a new knowledge base handler
-func NewKnowledgebaseHandler(kbService *service.KnowledgebaseService, userService *service.UserService) *KnowledgebaseHandler {
+func NewKnowledgebaseHandler(kbService *service.KnowledgebaseService, userService *service.UserService, documentService *service.DocumentService) *KnowledgebaseHandler {
 	return &KnowledgebaseHandler{
-		kbService:   kbService,
-		userService: userService,
+		kbService:       kbService,
+		userService:     userService,
+		documentService: documentService,
 	}
 }
 
@@ -581,7 +583,13 @@ func (h *KnowledgebaseHandler) GetMeta(c *gin.Context) {
 		}
 	}
 
-	jsonResponse(c, common.CodeSuccess, map[string]interface{}{}, "success")
+	meta, err := h.documentService.GetMetadataByKBs(kbIDs)
+	if err != nil {
+		jsonError(c, common.CodeExceptionError, err.Error())
+		return
+	}
+
+	jsonResponse(c, common.CodeSuccess, meta, "success")
 }
 
 // GetBasicInfo handles the get basic info request